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  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with this library; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  26  */
  27
  28 #include "config.h"
  29 #include <stdio.h>
  30 #ifdef HAVE_FLOAT_H
  31 # include <float.h>
  32 #endif
  33 #include "wined3d_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  36 #define GLINFO_LOCATION This->adapter->gl_info
  37
  38 /* Define the default light parameters as specified by MSDN */
  39 const WINED3DLIGHT WINED3D_default_light = {
  40
  41     WINED3DLIGHT_DIRECTIONAL, /* Type */
  42     { 1.0, 1.0, 1.0, 0.0 },   /* Diffuse r,g,b,a */
  43     { 0.0, 0.0, 0.0, 0.0 },   /* Specular r,g,b,a */
  44     { 0.0, 0.0, 0.0, 0.0 },   /* Ambient r,g,b,a, */
  45     { 0.0, 0.0, 0.0 },        /* Position x,y,z */
  46     { 0.0, 0.0, 1.0 },        /* Direction x,y,z */
  47     0.0,                      /* Range */
  48     0.0,                      /* Falloff */
  49     0.0, 0.0, 0.0,            /* Attenuation 0,1,2 */
  50     0.0,                      /* Theta */
  51     0.0                       /* Phi */
  52 };
  53
  54 /* static function declarations */
  55 static void IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource);
  56
  57 /* helper macros */
  58 #define D3DMEMCHECK(object, ppResult) if(NULL == object) { *ppResult = NULL; WARN("Out of memory\n"); return WINED3DERR_OUTOFVIDEOMEMORY;}
  59
  60 #define D3DCREATEOBJECTINSTANCE(object, type) { \
  61     object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
  62     D3DMEMCHECK(object, pp##type); \
  63     object->lpVtbl = &IWineD3D##type##_Vtbl;  \
  64     object->wineD3DDevice = This; \
  65     object->parent       = parent; \
  66     object->ref          = 1; \
  67     *pp##type = (IWineD3D##type *) object; \
  68 }
  69
  70 #define D3DCREATESHADEROBJECTINSTANCE(object, type) { \
  71     object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
  72     D3DMEMCHECK(object, pp##type); \
  73     object->lpVtbl = &IWineD3D##type##_Vtbl;  \
  74     object->parent          = parent; \
  75     object->baseShader.ref  = 1; \
  76     object->baseShader.device = (IWineD3DDevice*) This; \
  77     list_init(&object->baseShader.linked_programs); \
  78     *pp##type = (IWineD3D##type *) object; \
  79 }
  80
  81 #define  D3DCREATERESOURCEOBJECTINSTANCE(object, type, d3dtype, _size){ \
  82     object=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3D##type##Impl)); \
  83     D3DMEMCHECK(object, pp##type); \
  84     object->lpVtbl = &IWineD3D##type##_Vtbl;  \
  85     object->resource.wineD3DDevice   = This; \
  86     object->resource.parent          = parent; \
  87     object->resource.resourceType    = d3dtype; \
  88     object->resource.ref             = 1; \
  89     object->resource.pool            = Pool; \
  90     object->resource.format          = Format; \
  91     object->resource.usage           = Usage; \
  92     object->resource.size            = _size; \
  93     object->resource.priority        = 0; \
  94     list_init(&object->resource.privateData); \
  95     /* Check that we have enough video ram left */ \
  96     if (Pool == WINED3DPOOL_DEFAULT) { \
  97         if (IWineD3DDevice_GetAvailableTextureMem(iface) <= _size) { \
  98             WARN("Out of 'bogus' video memory\n"); \
  99             HeapFree(GetProcessHeap(), 0, object); \
 100             *pp##type = NULL; \
 101             return WINED3DERR_OUTOFVIDEOMEMORY; \
 102         } \
 103         WineD3DAdapterChangeGLRam(This, _size); \
 104     } \
 105     object->resource.heapMemory = (0 == _size ? NULL : HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, _size + RESOURCE_ALIGNMENT)); \
 106     if (object->resource.heapMemory == NULL && _size != 0) { \
 107         FIXME("Out of memory!\n"); \
 108         HeapFree(GetProcessHeap(), 0, object); \
 109         *pp##type = NULL; \
 110         return WINED3DERR_OUTOFVIDEOMEMORY; \
 111     } \
 112     object->resource.allocatedMemory = (BYTE *)(((ULONG_PTR) object->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1)); \
 113     *pp##type = (IWineD3D##type *) object; \
 114     IWineD3DDeviceImpl_AddResource(iface, (IWineD3DResource *)object) ;\
 115     TRACE("(%p) : Created resource %p\n", This, object); \
 116 }
 117
 118 #define D3DINITIALIZEBASETEXTURE(_basetexture) { \
 119     _basetexture.levels     = Levels; \
 120     _basetexture.filterType = (Usage & WINED3DUSAGE_AUTOGENMIPMAP) ? WINED3DTEXF_LINEAR : WINED3DTEXF_NONE; \
 121     _basetexture.LOD        = 0; \
 122     _basetexture.dirty      = TRUE; \
 123     _basetexture.is_srgb = FALSE; \
 124     _basetexture.srgb_mode_change_count = 0; \
 125 }
 126
 127 /**********************************************************
 128  * Global variable / Constants follow
 129  **********************************************************/
 130 const float identity[16] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};  /* When needed for comparisons */
 131
 132 /**********************************************************
 133  * IUnknown parts follows
 134  **********************************************************/
 135
 136 static HRESULT WINAPI IWineD3DDeviceImpl_QueryInterface(IWineD3DDevice *iface,REFIID riid,LPVOID *ppobj)
 137 {
 138     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 139
 140     TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
 141     if (IsEqualGUID(riid, &IID_IUnknown)
 142         || IsEqualGUID(riid, &IID_IWineD3DBase)
 143         || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
 144         IUnknown_AddRef(iface);
 145         *ppobj = This;
 146         return S_OK;
 147     }
 148     *ppobj = NULL;
 149     return E_NOINTERFACE;
 150 }
 151
 152 static ULONG WINAPI IWineD3DDeviceImpl_AddRef(IWineD3DDevice *iface) {
 153     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 154     ULONG refCount = InterlockedIncrement(&This->ref);
 155
 156     TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
 157     return refCount;
 158 }
 159
 160 static ULONG WINAPI IWineD3DDeviceImpl_Release(IWineD3DDevice *iface) {
 161     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 162     ULONG refCount = InterlockedDecrement(&This->ref);
 163
 164     TRACE("(%p) : Releasing from %d\n", This, refCount + 1);
 165
 166     if (!refCount) {
 167         /* TODO: Clean up all the surfaces and textures! */
 168         /* NOTE: You must release the parent if the object was created via a callback
 169         ** ***************************/
 170
 171         if (!list_empty(&This->resources)) {
 172             FIXME("(%p) Device released with resources still bound, acceptable but unexpected\n", This);
 173             dumpResources(&This->resources);
 174         }
 175
 176         if(This->contexts) ERR("Context array not freed!\n");
 177         if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
 178         This->haveHardwareCursor = FALSE;
 179
 180         IWineD3D_Release(This->wineD3D);
 181         This->wineD3D = NULL;
 182         HeapFree(GetProcessHeap(), 0, This);
 183         TRACE("Freed device  %p\n", This);
 184         This = NULL;
 185     }
 186     return refCount;
 187 }
 188
 189 /**********************************************************
 190  * IWineD3DDevice implementation follows
 191  **********************************************************/
 192 static HRESULT WINAPI IWineD3DDeviceImpl_GetParent(IWineD3DDevice *iface, IUnknown **pParent) {
 193     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 194     *pParent = This->parent;
 195     IUnknown_AddRef(This->parent);
 196     return WINED3D_OK;
 197 }
 198
 199 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexBuffer(IWineD3DDevice *iface, UINT Size, DWORD Usage,
 200                              DWORD FVF, WINED3DPOOL Pool, IWineD3DVertexBuffer** ppVertexBuffer, HANDLE *sharedHandle,
 201                              IUnknown *parent) {
 202     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 203     IWineD3DVertexBufferImpl *object;
 204     WINED3DFORMAT Format = WINED3DFMT_VERTEXDATA; /* Dummy format for now */
 205     int dxVersion = ( (IWineD3DImpl *) This->wineD3D)->dxVersion;
 206     BOOL conv;
 207
 208     if(Size == 0) {
 209         WARN("Size 0 requested, returning WINED3DERR_INVALIDCALL\n");
 210         *ppVertexBuffer = NULL;
 211         return WINED3DERR_INVALIDCALL;
 212     } else if(Pool == WINED3DPOOL_SCRATCH) {
 213         /* The d3d9 testsuit shows that this is not allowed. It doesn't make much sense
 214          * anyway, SCRATCH vertex buffers aren't usable anywhere
 215          */
 216         WARN("Vertex buffer in D3DPOOL_SCRATCH requested, returning WINED3DERR_INVALIDCALL\n");
 217         *ppVertexBuffer = NULL;
 218         return WINED3DERR_INVALIDCALL;
 219     }
 220
 221     D3DCREATERESOURCEOBJECTINSTANCE(object, VertexBuffer, WINED3DRTYPE_VERTEXBUFFER, Size)
 222
 223     TRACE("(%p) : Size=%d, Usage=0x%08x, FVF=%x, Pool=%d - Memory@%p, Iface@%p\n", This, Size, Usage, FVF, Pool, object->resource.allocatedMemory, object);
 224     *ppVertexBuffer = (IWineD3DVertexBuffer *)object;
 225
 226     object->fvf = FVF;
 227
 228     /* Observations show that drawStridedSlow is faster on dynamic VBs than converting +
 229      * drawStridedFast (half-life 2).
 230      *
 231      * Basically converting the vertices in the buffer is quite expensive, and observations
 232      * show that drawStridedSlow is faster than converting + uploading + drawStridedFast.
 233      * Therefore do not create a VBO for WINED3DUSAGE_DYNAMIC buffers.
 234      *
 235      * Direct3D7 has another problem: Its vertexbuffer api doesn't offer a way to specify
 236      * the range of vertices being locked, so each lock will require the whole buffer to be transformed.
 237      * Moreover geometry data in dx7 is quite simple, so drawStridedSlow isn't a big hit. A plus
 238      * is that the vertex buffers fvf can be trusted in dx7. So only create non-converted vbos for
 239      * dx7 apps.
 240      * There is a IDirect3DVertexBuffer7::Optimize call after which the buffer can't be locked any
 241      * more. In this call we can convert dx7 buffers too.
 242      */
 243     conv = ((FVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) || (FVF & (WINED3DFVF_DIFFUSE | WINED3DFVF_SPECULAR));
 244     if(!GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
 245         TRACE("Not creating a vbo because GL_ARB_vertex_buffer is not supported\n");
 246     } else if(Pool == WINED3DPOOL_SYSTEMMEM) {
 247         TRACE("Not creating a vbo because the vertex buffer is in system memory\n");
 248     } else if(Usage & WINED3DUSAGE_DYNAMIC) {
 249         TRACE("Not creating a vbo because the buffer has dynamic usage\n");
 250     } else if(dxVersion <= 7 && conv) {
 251         TRACE("Not creating a vbo because dxVersion is 7 and the fvf needs conversion\n");
 252     } else {
 253         object->Flags |= VBFLAG_CREATEVBO;
 254     }
 255     return WINED3D_OK;
 256 }
 257
 258 static void CreateIndexBufferVBO(IWineD3DDeviceImpl *This, IWineD3DIndexBufferImpl *object) {
 259     GLenum error, glUsage;
 260     TRACE("Creating VBO for Index Buffer %p\n", object);
 261
 262     /* The following code will modify the ELEMENT_ARRAY_BUFFER binding, make sure it is
 263      * restored on the next draw
 264      */
 265     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
 266
 267     /* Make sure that a context is there. Needed in a multithreaded environment. Otherwise this call is a nop */
 268     ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 269     ENTER_GL();
 270
 271     while(glGetError());
 272
 273     GL_EXTCALL(glGenBuffersARB(1, &object->vbo));
 274     error = glGetError();
 275     if(error != GL_NO_ERROR || object->vbo == 0) {
 276         ERR("Creating a vbo failed with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
 277         goto out;
 278     }
 279
 280     GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->vbo));
 281     error = glGetError();
 282     if(error != GL_NO_ERROR) {
 283         ERR("Failed to bind index buffer with error %s (%#x), continuing without vbo for this buffer\n", debug_glerror(error), error);
 284         goto out;
 285     }
 286
 287     /* Use static write only usage for now. Dynamic index buffers stay in sysmem, and due to the sysmem
 288         * copy no readback will be needed
 289         */
 290     glUsage = GL_STATIC_DRAW_ARB;
 291     GL_EXTCALL(glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, object->resource.size, NULL, glUsage));
 292     error = glGetError();
 293     if(error != GL_NO_ERROR) {
 294         ERR("Failed to initialize the index buffer with error %s (%#x)\n", debug_glerror(error), error);
 295         goto out;
 296     }
 297     LEAVE_GL();
 298     TRACE("Successfully created vbo %d for index buffer %p\n", object->vbo, object);
 299     return;
 300
 301 out:
 302     GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
 303     GL_EXTCALL(glDeleteBuffersARB(1, &object->vbo));
 304     LEAVE_GL();
 305     object->vbo = 0;
 306 }
 307
 308 static HRESULT WINAPI IWineD3DDeviceImpl_CreateIndexBuffer(IWineD3DDevice *iface, UINT Length, DWORD Usage,
 309                                                     WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DIndexBuffer** ppIndexBuffer,
 310                                                     HANDLE *sharedHandle, IUnknown *parent) {
 311     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 312     IWineD3DIndexBufferImpl *object;
 313     TRACE("(%p) Creating index buffer\n", This);
 314
 315     /* Allocate the storage for the device */
 316     D3DCREATERESOURCEOBJECTINSTANCE(object,IndexBuffer,WINED3DRTYPE_INDEXBUFFER, Length)
 317
 318     if(Pool != WINED3DPOOL_SYSTEMMEM && !(Usage & WINED3DUSAGE_DYNAMIC) && GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
 319         CreateIndexBufferVBO(This, object);
 320     }
 321
 322     TRACE("(%p) : Len=%d, Use=%x, Format=(%u,%s), Pool=%d - Memory@%p, Iface@%p\n", This, Length, Usage, Format,
 323                            debug_d3dformat(Format), Pool, object, object->resource.allocatedMemory);
 324     *ppIndexBuffer = (IWineD3DIndexBuffer *) object;
 325
 326     return WINED3D_OK;
 327 }
 328
 329 static HRESULT WINAPI IWineD3DDeviceImpl_CreateStateBlock(IWineD3DDevice* iface, WINED3DSTATEBLOCKTYPE Type, IWineD3DStateBlock** ppStateBlock, IUnknown *parent) {
 330
 331     IWineD3DDeviceImpl     *This = (IWineD3DDeviceImpl *)iface;
 332     IWineD3DStateBlockImpl *object;
 333     int i, j;
 334     HRESULT temp_result;
 335
 336     D3DCREATEOBJECTINSTANCE(object, StateBlock)
 337     object->blockType     = Type;
 338
 339     for(i = 0; i < LIGHTMAP_SIZE; i++) {
 340         list_init(&object->lightMap[i]);
 341     }
 342
 343     temp_result = allocate_shader_constants(object);
 344     if (FAILED(temp_result))
 345     {
 346         HeapFree(GetProcessHeap(), 0, object);
 347         return temp_result;
 348     }
 349
 350     /* Special case - Used during initialization to produce a placeholder stateblock
 351           so other functions called can update a state block                         */
 352     if (Type == WINED3DSBT_INIT) {
 353         /* Don't bother increasing the reference count otherwise a device will never
 354            be freed due to circular dependencies                                   */
 355         return WINED3D_OK;
 356     }
 357
 358     /* Otherwise, might as well set the whole state block to the appropriate values  */
 359     if (This->stateBlock != NULL)
 360         stateblock_copy((IWineD3DStateBlock*) object, (IWineD3DStateBlock*) This->stateBlock);
 361     else
 362         memset(object->streamFreq, 1, sizeof(object->streamFreq));
 363
 364     /* Reset the ref and type after kludging it */
 365     object->wineD3DDevice = This;
 366     object->ref           = 1;
 367     object->blockType     = Type;
 368
 369     TRACE("Updating changed flags appropriate for type %d\n", Type);
 370
 371     if (Type == WINED3DSBT_ALL) {
 372
 373         TRACE("ALL => Pretend everything has changed\n");
 374         stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, TRUE);
 375
 376         /* Lights are not part of the changed / set structure */
 377         for(j = 0; j < LIGHTMAP_SIZE; j++) {
 378             struct list *e;
 379             LIST_FOR_EACH(e, &object->lightMap[j]) {
 380                 PLIGHTINFOEL *light = LIST_ENTRY(e, PLIGHTINFOEL, entry);
 381                 light->changed = TRUE;
 382                 light->enabledChanged = TRUE;
 383             }
 384         }
 385         for(j = 1; j <= WINEHIGHEST_RENDER_STATE; j++) {
 386             object->contained_render_states[j - 1] = j;
 387         }
 388         object->num_contained_render_states = WINEHIGHEST_RENDER_STATE;
 389         /* TODO: Filter unused transforms between TEXTURE8 and WORLD0? */
 390         for(j = 1; j <= HIGHEST_TRANSFORMSTATE; j++) {
 391             object->contained_transform_states[j - 1] = j;
 392         }
 393         object->num_contained_transform_states = HIGHEST_TRANSFORMSTATE;
 394         for(j = 0; j < GL_LIMITS(vshader_constantsF); j++) {
 395             object->contained_vs_consts_f[j] = j;
 396         }
 397         object->num_contained_vs_consts_f = GL_LIMITS(vshader_constantsF);
 398         for(j = 0; j < MAX_CONST_I; j++) {
 399             object->contained_vs_consts_i[j] = j;
 400         }
 401         object->num_contained_vs_consts_i = MAX_CONST_I;
 402         for(j = 0; j < MAX_CONST_B; j++) {
 403             object->contained_vs_consts_b[j] = j;
 404         }
 405         object->num_contained_vs_consts_b = MAX_CONST_B;
 406         for(j = 0; j < GL_LIMITS(pshader_constantsF); j++) {
 407             object->contained_ps_consts_f[j] = j;
 408         }
 409         object->num_contained_ps_consts_f = GL_LIMITS(pshader_constantsF);
 410         for(j = 0; j < MAX_CONST_I; j++) {
 411             object->contained_ps_consts_i[j] = j;
 412         }
 413         object->num_contained_ps_consts_i = MAX_CONST_I;
 414         for(j = 0; j < MAX_CONST_B; j++) {
 415             object->contained_ps_consts_b[j] = j;
 416         }
 417         object->num_contained_ps_consts_b = MAX_CONST_B;
 418         for(i = 0; i < MAX_TEXTURES; i++) {
 419             for(j = 1; j <= WINED3D_HIGHEST_TEXTURE_STATE; j++) {
 420                 object->contained_tss_states[object->num_contained_tss_states].stage = i;
 421                 object->contained_tss_states[object->num_contained_tss_states].state = j;
 422                 object->num_contained_tss_states++;
 423             }
 424         }
 425         for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
 426             for(j = 1; j <= WINED3D_HIGHEST_SAMPLER_STATE; j++) {
 427                 object->contained_sampler_states[object->num_contained_sampler_states].stage = i;
 428                 object->contained_sampler_states[object->num_contained_sampler_states].state = j;
 429                 object->num_contained_sampler_states++;
 430             }
 431         }
 432
 433         for(i = 0; i < MAX_STREAMS; i++) {
 434             if(object->streamSource[i]) {
 435                 IWineD3DVertexBuffer_AddRef(object->streamSource[i]);
 436             }
 437         }
 438         if(object->pIndexData) {
 439             IWineD3DIndexBuffer_AddRef(object->pIndexData);
 440         }
 441         if(object->vertexShader) {
 442             IWineD3DVertexShader_AddRef(object->vertexShader);
 443         }
 444         if(object->pixelShader) {
 445             IWineD3DPixelShader_AddRef(object->pixelShader);
 446         }
 447
 448     } else if (Type == WINED3DSBT_PIXELSTATE) {
 449
 450         TRACE("PIXELSTATE => Pretend all pixel shates have changed\n");
 451         stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, FALSE);
 452
 453         object->changed.pixelShader = TRUE;
 454
 455         /* Pixel Shader Constants */
 456         for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
 457             object->contained_ps_consts_f[i] = i;
 458             object->changed.pixelShaderConstantsF[i] = TRUE;
 459         }
 460         object->num_contained_ps_consts_f = GL_LIMITS(pshader_constantsF);
 461         for (i = 0; i < MAX_CONST_B; ++i) {
 462             object->contained_ps_consts_b[i] = i;
 463             object->changed.pixelShaderConstantsB |= (1 << i);
 464         }
 465         object->num_contained_ps_consts_b = MAX_CONST_B;
 466         for (i = 0; i < MAX_CONST_I; ++i) {
 467             object->contained_ps_consts_i[i] = i;
 468             object->changed.pixelShaderConstantsI |= (1 << i);
 469         }
 470         object->num_contained_ps_consts_i = MAX_CONST_I;
 471
 472         for (i = 0; i < NUM_SAVEDPIXELSTATES_R; i++) {
 473             object->changed.renderState[SavedPixelStates_R[i]] = TRUE;
 474             object->contained_render_states[i] = SavedPixelStates_R[i];
 475         }
 476         object->num_contained_render_states = NUM_SAVEDPIXELSTATES_R;
 477         for (j = 0; j < MAX_TEXTURES; j++) {
 478             for (i = 0; i < NUM_SAVEDPIXELSTATES_T; i++) {
 479                 object->changed.textureState[j][SavedPixelStates_T[i]] = TRUE;
 480                 object->contained_tss_states[object->num_contained_tss_states].stage = j;
 481                 object->contained_tss_states[object->num_contained_tss_states].state = SavedPixelStates_T[i];
 482                 object->num_contained_tss_states++;
 483             }
 484         }
 485         for (j = 0 ; j < MAX_COMBINED_SAMPLERS; j++) {
 486             for (i =0; i < NUM_SAVEDPIXELSTATES_S;i++) {
 487                 object->changed.samplerState[j][SavedPixelStates_S[i]] = TRUE;
 488                 object->contained_sampler_states[object->num_contained_sampler_states].stage = j;
 489                 object->contained_sampler_states[object->num_contained_sampler_states].state = SavedPixelStates_S[i];
 490                 object->num_contained_sampler_states++;
 491             }
 492         }
 493         if(object->pixelShader) {
 494             IWineD3DPixelShader_AddRef(object->pixelShader);
 495         }
 496
 497         /* Pixel state blocks do not contain vertex buffers. Set them to NULL to avoid wrong refcounting
 498          * on them. This makes releasing the buffer easier
 499          */
 500         for(i = 0; i < MAX_STREAMS; i++) {
 501             object->streamSource[i] = NULL;
 502         }
 503         object->pIndexData = NULL;
 504         object->vertexShader = NULL;
 505
 506     } else if (Type == WINED3DSBT_VERTEXSTATE) {
 507
 508         TRACE("VERTEXSTATE => Pretend all vertex shates have changed\n");
 509         stateblock_savedstates_set((IWineD3DStateBlock*) object, &object->changed, FALSE);
 510
 511         object->changed.vertexShader = TRUE;
 512
 513         /* Vertex Shader Constants */
 514         for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
 515             object->changed.vertexShaderConstantsF[i] = TRUE;
 516             object->contained_vs_consts_f[i] = i;
 517         }
 518         object->num_contained_vs_consts_f = GL_LIMITS(vshader_constantsF);
 519         for (i = 0; i < MAX_CONST_B; ++i) {
 520             object->contained_vs_consts_b[i] = i;
 521             object->changed.vertexShaderConstantsB |= (1 << i);
 522         }
 523         object->num_contained_vs_consts_b = MAX_CONST_B;
 524         for (i = 0; i < MAX_CONST_I; ++i) {
 525             object->contained_vs_consts_i[i] = i;
 526             object->changed.vertexShaderConstantsI |= (1 << i);
 527         }
 528         object->num_contained_vs_consts_i = MAX_CONST_I;
 529         for (i = 0; i < NUM_SAVEDVERTEXSTATES_R; i++) {
 530             object->changed.renderState[SavedVertexStates_R[i]] = TRUE;
 531             object->contained_render_states[i] = SavedVertexStates_R[i];
 532         }
 533         object->num_contained_render_states = NUM_SAVEDVERTEXSTATES_R;
 534         for (j = 0; j < MAX_TEXTURES; j++) {
 535             for (i = 0; i < NUM_SAVEDVERTEXSTATES_T; i++) {
 536                 object->changed.textureState[j][SavedVertexStates_T[i]] = TRUE;
 537                 object->contained_tss_states[object->num_contained_tss_states].stage = j;
 538                 object->contained_tss_states[object->num_contained_tss_states].state = SavedVertexStates_T[i];
 539                 object->num_contained_tss_states++;
 540             }
 541         }
 542         for (j = 0 ; j < MAX_COMBINED_SAMPLERS; j++){
 543             for (i =0; i < NUM_SAVEDVERTEXSTATES_S;i++) {
 544                 object->changed.samplerState[j][SavedVertexStates_S[i]] = TRUE;
 545                 object->contained_sampler_states[object->num_contained_sampler_states].stage = j;
 546                 object->contained_sampler_states[object->num_contained_sampler_states].state = SavedVertexStates_S[i];
 547                 object->num_contained_sampler_states++;
 548             }
 549         }
 550
 551         for(j = 0; j < LIGHTMAP_SIZE; j++) {
 552             struct list *e;
 553             LIST_FOR_EACH(e, &object->lightMap[j]) {
 554                 PLIGHTINFOEL *light = LIST_ENTRY(e, PLIGHTINFOEL, entry);
 555                 light->changed = TRUE;
 556                 light->enabledChanged = TRUE;
 557             }
 558         }
 559
 560         for(i = 0; i < MAX_STREAMS; i++) {
 561             if(object->streamSource[i]) {
 562                 IWineD3DVertexBuffer_AddRef(object->streamSource[i]);
 563             }
 564         }
 565         if(object->vertexShader) {
 566             IWineD3DVertexShader_AddRef(object->vertexShader);
 567         }
 568         object->pIndexData = NULL;
 569         object->pixelShader = NULL;
 570     } else {
 571         FIXME("Unrecognized state block type %d\n", Type);
 572     }
 573
 574     TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, object);
 575     return WINED3D_OK;
 576 }
 577
 578 /* ************************************
 579 MSDN:
 580 [in] Render targets are not lockable unless the application specifies TRUE for Lockable. Note that lockable render targets reduce performance on some graphics hardware.
 581
 582 Discard
 583  [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
 584
 585 If this flag is set, the contents of the depth stencil buffer will be invalid after calling either IDirect3DDevice9::Present or IDirect3DDevice9::SetDepthStencilSurface with a different depth surface.
 586
 587 ******************************** */
 588
 589 static HRESULT  WINAPI IWineD3DDeviceImpl_CreateSurface(IWineD3DDevice *iface, UINT Width, UINT Height, WINED3DFORMAT Format, BOOL Lockable, BOOL Discard, UINT Level, IWineD3DSurface **ppSurface,WINED3DRESOURCETYPE Type, DWORD Usage, WINED3DPOOL Pool, WINED3DMULTISAMPLE_TYPE MultiSample ,DWORD MultisampleQuality, HANDLE* pSharedHandle, WINED3DSURFTYPE Impl, IUnknown *parent) {
 590     IWineD3DDeviceImpl  *This = (IWineD3DDeviceImpl *)iface;
 591     IWineD3DSurfaceImpl *object; /*NOTE: impl ref allowed since this is a create function */
 592     unsigned int Size       = 1;
 593     const struct GlPixelFormatDesc *glDesc;
 594     const StaticPixelFormatDesc *tableEntry = getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
 595     UINT mul_4w, mul_4h;
 596     TRACE("(%p) Create surface\n",This);
 597
 598     /** FIXME: Check ranges on the inputs are valid
 599      * MSDN
 600      *   MultisampleQuality
 601      *    [in] Quality level. The valid range is between zero and one less than the level
 602      *    returned by pQualityLevels used by IDirect3D9::CheckDeviceMultiSampleType.
 603      *    Passing a larger value returns the error WINED3DERR_INVALIDCALL. The MultisampleQuality
 604      *    values of paired render targets, depth stencil surfaces, and the MultiSample type
 605      *    must all match.
 606       *******************************/
 607
 608
 609     /**
 610     * TODO: Discard MSDN
 611     * [in] Set this flag to TRUE to enable z-buffer discarding, and FALSE otherwise.
 612     *
 613     * If this flag is set, the contents of the depth stencil buffer will be
 614     * invalid after calling either IDirect3DDevice9::Present or  * IDirect3DDevice9::SetDepthStencilSurface
 615     * with a different depth surface.
 616     *
 617     *This flag has the same behavior as the constant, D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL, in D3DPRESENTFLAG.
 618     ***************************/
 619
 620     if(MultisampleQuality > 0) {
 621         FIXME("MultisampleQuality set to %d, substituting 0\n", MultisampleQuality);
 622         MultisampleQuality=0;
 623     }
 624
 625     /** FIXME: Check that the format is supported
 626     *    by the device.
 627       *******************************/
 628
 629     /** DXTn mipmaps use the same number of 'levels' down to eg. 8x1, but since
 630      *  it is based around 4x4 pixel blocks it requires padding, so allocate enough
 631      *  space!
 632       *********************************/
 633     mul_4w = (Width + 3) & ~3;
 634     mul_4h = (Height + 3) & ~3;
 635     if (WINED3DFMT_UNKNOWN == Format) {
 636         Size = 0;
 637     } else if (Format == WINED3DFMT_DXT1) {
 638         /* DXT1 is half byte per pixel */
 639         Size = (mul_4w * tableEntry->bpp * mul_4h) >> 1;
 640
 641     } else if (Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3 ||
 642                Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5 ||
 643                Format == WINED3DFMT_ATI2N) {
 644         Size = (mul_4w * tableEntry->bpp * mul_4h);
 645     } else {
 646        /* The pitch is a multiple of 4 bytes */
 647         Size = ((Width * tableEntry->bpp) + This->surface_alignment - 1) & ~(This->surface_alignment - 1);
 648         Size *= Height;
 649     }
 650
 651     if(glDesc->heightscale != 0.0) Size *= glDesc->heightscale;
 652
 653     /** Create and initialise the surface resource **/
 654     D3DCREATERESOURCEOBJECTINSTANCE(object,Surface,WINED3DRTYPE_SURFACE, Size)
 655     /* "Standalone" surface */
 656     IWineD3DSurface_SetContainer((IWineD3DSurface *)object, NULL);
 657
 658     object->currentDesc.Width      = Width;
 659     object->currentDesc.Height     = Height;
 660     object->currentDesc.MultiSampleType    = MultiSample;
 661     object->currentDesc.MultiSampleQuality = MultisampleQuality;
 662     object->glDescription.level            = Level;
 663     object->heightscale                    = glDesc->heightscale != 0.0 ? glDesc->heightscale : 1.0;
 664     list_init(&object->overlays);
 665
 666     /* Flags */
 667     object->Flags      = SFLAG_NORMCOORD; /* Default to normalized coords */
 668     object->Flags     |= Discard ? SFLAG_DISCARD : 0;
 669     object->Flags     |= (WINED3DFMT_D16_LOCKABLE == Format) ? SFLAG_LOCKABLE : 0;
 670     object->Flags     |= Lockable ? SFLAG_LOCKABLE : 0;
 671
 672
 673     if (WINED3DFMT_UNKNOWN != Format) {
 674         object->bytesPerPixel = tableEntry->bpp;
 675     } else {
 676         object->bytesPerPixel = 0;
 677     }
 678
 679     /** TODO: change this into a texture transform matrix so that it's processed in hardware **/
 680
 681     TRACE("Pool %d %d %d %d\n",Pool, WINED3DPOOL_DEFAULT, WINED3DPOOL_MANAGED, WINED3DPOOL_SYSTEMMEM);
 682
 683     /** Quick lockable sanity check TODO: remove this after surfaces, usage and lockability have been debugged properly
 684     * this function is too deep to need to care about things like this.
 685     * Levels need to be checked too, and possibly Type since they all affect what can be done.
 686     * ****************************************/
 687     switch(Pool) {
 688     case WINED3DPOOL_SCRATCH:
 689         if(!Lockable)
 690             FIXME("Create surface called with a pool of SCRATCH and a Lockable of FALSE "
 691                 "which are mutually exclusive, setting lockable to TRUE\n");
 692                 Lockable = TRUE;
 693     break;
 694     case WINED3DPOOL_SYSTEMMEM:
 695         if(!Lockable) FIXME("Create surface called with a pool of SYSTEMMEM and a Lockable of FALSE, "
 696                                     "this is acceptable but unexpected (I can't know how the surface can be usable!)\n");
 697     case WINED3DPOOL_MANAGED:
 698         if(Usage == WINED3DUSAGE_DYNAMIC) FIXME("Create surface called with a pool of MANAGED and a "
 699                                                 "Usage of DYNAMIC which are mutually exclusive, not doing "
 700                                                 "anything just telling you.\n");
 701     break;
 702     case WINED3DPOOL_DEFAULT: /*TODO: Create offscreen plain can cause this check to fail..., find out if it should */
 703         if(!(Usage & WINED3DUSAGE_DYNAMIC) && !(Usage & WINED3DUSAGE_RENDERTARGET)
 704            && !(Usage && WINED3DUSAGE_DEPTHSTENCIL ) && Lockable)
 705             WARN("Creating a surface with a POOL of DEFAULT with Lockable true, that doesn't specify DYNAMIC usage.\n");
 706     break;
 707     default:
 708         FIXME("(%p) Unknown pool %d\n", This, Pool);
 709     break;
 710     };
 711
 712     if (Usage & WINED3DUSAGE_RENDERTARGET && Pool != WINED3DPOOL_DEFAULT) {
 713         FIXME("Trying to create a render target that isn't in the default pool\n");
 714     }
 715
 716     /* mark the texture as dirty so that it gets loaded first time around*/
 717     IWineD3DSurface_AddDirtyRect(*ppSurface, NULL);
 718     TRACE("(%p) : w(%d) h(%d) fmt(%d,%s) lockable(%d) surf@%p, surfmem@%p, %d bytes\n",
 719            This, Width, Height, Format, debug_d3dformat(Format),
 720            (WINED3DFMT_D16_LOCKABLE == Format), *ppSurface, object->resource.allocatedMemory, object->resource.size);
 721
 722     /* Look at the implementation and set the correct Vtable */
 723     switch(Impl) {
 724         case SURFACE_OPENGL:
 725             /* Check if a 3D adapter is available when creating gl surfaces */
 726             if(!This->adapter) {
 727                 ERR("OpenGL surfaces are not available without opengl\n");
 728                 HeapFree(GetProcessHeap(), 0, object->resource.allocatedMemory);
 729                 HeapFree(GetProcessHeap(), 0, object);
 730                 return WINED3DERR_NOTAVAILABLE;
 731             }
 732             break;
 733
 734         case SURFACE_GDI:
 735             object->lpVtbl = &IWineGDISurface_Vtbl;
 736             break;
 737
 738         default:
 739             /* To be sure to catch this */
 740             ERR("Unknown requested surface implementation %d!\n", Impl);
 741             IWineD3DSurface_Release((IWineD3DSurface *) object);
 742             return WINED3DERR_INVALIDCALL;
 743     }
 744
 745     list_init(&object->renderbuffers);
 746
 747     /* Call the private setup routine */
 748     return IWineD3DSurface_PrivateSetup( (IWineD3DSurface *) object );
 749
 750 }
 751
 752 static HRESULT  WINAPI IWineD3DDeviceImpl_CreateTexture(IWineD3DDevice *iface, UINT Width, UINT Height, UINT Levels,
 753                                                  DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
 754                                                  IWineD3DTexture** ppTexture, HANDLE* pSharedHandle, IUnknown *parent,
 755                                                  D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
 756
 757     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
 758     IWineD3DTextureImpl *object;
 759     unsigned int i;
 760     UINT tmpW;
 761     UINT tmpH;
 762     HRESULT hr;
 763     unsigned int pow2Width;
 764     unsigned int pow2Height;
 765     const struct GlPixelFormatDesc *glDesc;
 766     getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
 767
 768     TRACE("(%p) : Width %d, Height %d, Levels %d, Usage %#x\n", This, Width, Height, Levels, Usage);
 769     TRACE("Format %#x (%s), Pool %#x, ppTexture %p, pSharedHandle %p, parent %p\n",
 770             Format, debug_d3dformat(Format), Pool, ppTexture, pSharedHandle, parent);
 771
 772     /* TODO: It should only be possible to create textures for formats
 773              that are reported as supported */
 774     if (WINED3DFMT_UNKNOWN >= Format) {
 775         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
 776         return WINED3DERR_INVALIDCALL;
 777     }
 778
 779     D3DCREATERESOURCEOBJECTINSTANCE(object, Texture, WINED3DRTYPE_TEXTURE, 0);
 780     D3DINITIALIZEBASETEXTURE(object->baseTexture);
 781     object->width  = Width;
 782     object->height = Height;
 783
 784     if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING) {
 785         object->baseTexture.minMipLookup = minMipLookup;
 786         object->baseTexture.magLookup    = magLookup;
 787     } else {
 788         object->baseTexture.minMipLookup = minMipLookup_noFilter;
 789         object->baseTexture.magLookup    = magLookup_noFilter;
 790     }
 791
 792     /** Non-power2 support **/
 793     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
 794         pow2Width = Width;
 795         pow2Height = Height;
 796     } else {
 797         /* Find the nearest pow2 match */
 798         pow2Width = pow2Height = 1;
 799         while (pow2Width < Width) pow2Width <<= 1;
 800         while (pow2Height < Height) pow2Height <<= 1;
 801
 802         if(pow2Width != Width || pow2Height != Height) {
 803             if(Levels > 1) {
 804                 WARN("Attempted to create a mipmapped np2 texture without unconditional np2 support\n");
 805                 HeapFree(GetProcessHeap(), 0, object);
 806                 *ppTexture = NULL;
 807                 return WINED3DERR_INVALIDCALL;
 808             } else {
 809                 Levels = 1;
 810             }
 811         }
 812     }
 813
 814     /** FIXME: add support for real non-power-two if it's provided by the video card **/
 815     /* Precalculated scaling for 'faked' non power of two texture coords.
 816        Second also don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
 817        is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
 818        doesn't work in combination with ARB_TEXTURE_RECTANGLE.
 819     */
 820     if(GL_SUPPORT(WINE_NORMALIZED_TEXRECT) && (Width != pow2Width || Height != pow2Height)) {
 821         object->baseTexture.pow2Matrix[0] =  1.0;
 822         object->baseTexture.pow2Matrix[5] =  1.0;
 823         object->baseTexture.pow2Matrix[10] = 1.0;
 824         object->baseTexture.pow2Matrix[15] = 1.0;
 825         object->target = GL_TEXTURE_2D;
 826         object->cond_np2 = TRUE;
 827         object->baseTexture.minMipLookup = minMipLookup_noFilter;
 828     } else if(GL_SUPPORT(ARB_TEXTURE_RECTANGLE) &&
 829        (Width != pow2Width || Height != pow2Height) &&
 830        !((Format == WINED3DFMT_P8) && GL_SUPPORT(EXT_PALETTED_TEXTURE) && (wined3d_settings.rendertargetlock_mode == RTL_READTEX || wined3d_settings.rendertargetlock_mode == RTL_TEXTEX)))
 831     {
 832         object->baseTexture.pow2Matrix[0] =  (float)Width;
 833         object->baseTexture.pow2Matrix[5] =  (float)Height;
 834         object->baseTexture.pow2Matrix[10] = 1.0;
 835         object->baseTexture.pow2Matrix[15] = 1.0;
 836         object->target = GL_TEXTURE_RECTANGLE_ARB;
 837         object->cond_np2 = TRUE;
 838         object->baseTexture.minMipLookup = minMipLookup_noFilter;
 839     } else {
 840         object->baseTexture.pow2Matrix[0] =  (((float)Width)  / ((float)pow2Width));
 841         object->baseTexture.pow2Matrix[5] =  (((float)Height) / ((float)pow2Height));
 842         object->baseTexture.pow2Matrix[10] = 1.0;
 843         object->baseTexture.pow2Matrix[15] = 1.0;
 844         object->target = GL_TEXTURE_2D;
 845         object->cond_np2 = FALSE;
 846     }
 847     TRACE(" xf(%f) yf(%f)\n", object->baseTexture.pow2Matrix[0], object->baseTexture.pow2Matrix[5]);
 848
 849     /* Calculate levels for mip mapping */
 850     if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
 851         if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
 852             WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
 853             return WINED3DERR_INVALIDCALL;
 854         }
 855         if(Levels > 1) {
 856             WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
 857             return WINED3DERR_INVALIDCALL;
 858         }
 859         object->baseTexture.levels = 1;
 860     } else if (Levels == 0) {
 861         object->baseTexture.levels = wined3d_log2i(max(Width, Height)) + 1;
 862         TRACE("Calculated levels = %d\n", object->baseTexture.levels);
 863     }
 864
 865     /* Generate all the surfaces */
 866     tmpW = Width;
 867     tmpH = Height;
 868     for (i = 0; i < object->baseTexture.levels; i++)
 869     {
 870         /* use the callback to create the texture surface */
 871         hr = D3DCB_CreateSurface(This->parent, parent, tmpW, tmpH, Format, Usage, Pool, i, WINED3DCUBEMAP_FACE_POSITIVE_X, &object->surfaces[i],NULL);
 872         if (hr!= WINED3D_OK || ( (IWineD3DSurfaceImpl *) object->surfaces[i])->Flags & SFLAG_OVERSIZE) {
 873             FIXME("Failed to create surface  %p\n", object);
 874             /* clean up */
 875             object->surfaces[i] = NULL;
 876             IWineD3DTexture_Release((IWineD3DTexture *)object);
 877
 878             *ppTexture = NULL;
 879             return hr;
 880         }
 881
 882         IWineD3DSurface_SetContainer(object->surfaces[i], (IWineD3DBase *)object);
 883         TRACE("Created surface level %d @ %p\n", i, object->surfaces[i]);
 884         surface_set_texture_target(object->surfaces[i], object->target);
 885         /* calculate the next mipmap level */
 886         tmpW = max(1, tmpW >> 1);
 887         tmpH = max(1, tmpH >> 1);
 888     }
 889     object->baseTexture.shader_color_fixup = glDesc->color_fixup;
 890
 891     TRACE("(%p) : Created  texture %p\n", This, object);
 892     return WINED3D_OK;
 893 }
 894
 895 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface,
 896                                                       UINT Width, UINT Height, UINT Depth,
 897                                                       UINT Levels, DWORD Usage,
 898                                                       WINED3DFORMAT Format, WINED3DPOOL Pool,
 899                                                       IWineD3DVolumeTexture **ppVolumeTexture,
 900                                                       HANDLE *pSharedHandle, IUnknown *parent,
 901                                                       D3DCB_CREATEVOLUMEFN D3DCB_CreateVolume) {
 902
 903     IWineD3DDeviceImpl        *This = (IWineD3DDeviceImpl *)iface;
 904     IWineD3DVolumeTextureImpl *object;
 905     unsigned int               i;
 906     UINT                       tmpW;
 907     UINT                       tmpH;
 908     UINT                       tmpD;
 909     const struct GlPixelFormatDesc *glDesc;
 910
 911     getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
 912
 913     /* TODO: It should only be possible to create textures for formats
 914              that are reported as supported */
 915     if (WINED3DFMT_UNKNOWN >= Format) {
 916         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
 917         return WINED3DERR_INVALIDCALL;
 918     }
 919     if(!GL_SUPPORT(EXT_TEXTURE3D)) {
 920         WARN("(%p) : Texture cannot be created - no volume texture support\n", This);
 921         return WINED3DERR_INVALIDCALL;
 922     }
 923
 924     D3DCREATERESOURCEOBJECTINSTANCE(object, VolumeTexture, WINED3DRTYPE_VOLUMETEXTURE, 0);
 925     D3DINITIALIZEBASETEXTURE(object->baseTexture);
 926
 927     TRACE("(%p) : W(%d) H(%d) D(%d), Lvl(%d) Usage(%d), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
 928           Depth, Levels, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
 929
 930     /* Is NP2 support for volumes needed? */
 931     object->baseTexture.pow2Matrix[ 0] = 1.0;
 932     object->baseTexture.pow2Matrix[ 5] = 1.0;
 933     object->baseTexture.pow2Matrix[10] = 1.0;
 934     object->baseTexture.pow2Matrix[15] = 1.0;
 935
 936     if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING) {
 937         object->baseTexture.minMipLookup = minMipLookup;
 938         object->baseTexture.magLookup    = magLookup;
 939     } else {
 940         object->baseTexture.minMipLookup = minMipLookup_noFilter;
 941         object->baseTexture.magLookup    = magLookup_noFilter;
 942     }
 943
 944     /* Calculate levels for mip mapping */
 945     if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
 946         if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
 947             WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
 948             return WINED3DERR_INVALIDCALL;
 949         }
 950         if(Levels > 1) {
 951             WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
 952             return WINED3DERR_INVALIDCALL;
 953         }
 954         object->baseTexture.levels = 1;
 955     } else if (Levels == 0) {
 956         object->baseTexture.levels = wined3d_log2i(max(max(Width, Height), Depth)) + 1;
 957         TRACE("Calculated levels = %d\n", object->baseTexture.levels);
 958     }
 959
 960     /* Generate all the surfaces */
 961     tmpW = Width;
 962     tmpH = Height;
 963     tmpD = Depth;
 964
 965     for (i = 0; i < object->baseTexture.levels; i++)
 966     {
 967         HRESULT hr;
 968         /* Create the volume */
 969         hr = D3DCB_CreateVolume(This->parent, parent, tmpW, tmpH, tmpD, Format, Pool, Usage,
 970                                 &object->volumes[i], pSharedHandle);
 971
 972         if(FAILED(hr)) {
 973             ERR("Creating a volume for the volume texture failed(%08x)\n", hr);
 974             IWineD3DVolumeTexture_Release((IWineD3DVolumeTexture *) object);
 975             *ppVolumeTexture = NULL;
 976             return hr;
 977         }
 978
 979         /* Set its container to this object */
 980         IWineD3DVolume_SetContainer(object->volumes[i], (IWineD3DBase *)object);
 981
 982         /* calculate the next mipmap level */
 983         tmpW = max(1, tmpW >> 1);
 984         tmpH = max(1, tmpH >> 1);
 985         tmpD = max(1, tmpD >> 1);
 986     }
 987     object->baseTexture.shader_color_fixup = glDesc->color_fixup;
 988
 989     *ppVolumeTexture = (IWineD3DVolumeTexture *) object;
 990     TRACE("(%p) : Created volume texture %p\n", This, object);
 991     return WINED3D_OK;
 992 }
 993
 994 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface,
 995                                                UINT Width, UINT Height, UINT Depth,
 996                                                DWORD Usage,
 997                                                WINED3DFORMAT Format, WINED3DPOOL Pool,
 998                                                IWineD3DVolume** ppVolume,
 999                                                HANDLE* pSharedHandle, IUnknown *parent) {
1000
1001     IWineD3DDeviceImpl        *This = (IWineD3DDeviceImpl *)iface;
1002     IWineD3DVolumeImpl        *object; /** NOTE: impl ref allowed since this is a create function **/
1003     const StaticPixelFormatDesc *formatDesc  = getFormatDescEntry(Format, NULL, NULL);
1004
1005     if(!GL_SUPPORT(EXT_TEXTURE3D)) {
1006         WARN("(%p) : Volume cannot be created - no volume texture support\n", This);
1007         return WINED3DERR_INVALIDCALL;
1008     }
1009
1010     D3DCREATERESOURCEOBJECTINSTANCE(object, Volume, WINED3DRTYPE_VOLUME, ((Width * formatDesc->bpp) * Height * Depth))
1011
1012     TRACE("(%p) : W(%d) H(%d) D(%d), Usage(%d), Fmt(%u,%s), Pool(%s)\n", This, Width, Height,
1013           Depth, Usage, Format, debug_d3dformat(Format), debug_d3dpool(Pool));
1014
1015     object->currentDesc.Width   = Width;
1016     object->currentDesc.Height  = Height;
1017     object->currentDesc.Depth   = Depth;
1018     object->bytesPerPixel       = formatDesc->bpp;
1019
1020     /** Note: Volume textures cannot be dxtn, hence no need to check here **/
1021     object->lockable            = TRUE;
1022     object->locked              = FALSE;
1023     memset(&object->lockedBox, 0, sizeof(WINED3DBOX));
1024     object->dirty               = TRUE;
1025
1026     return IWineD3DVolume_AddDirtyBox((IWineD3DVolume *) object, NULL);
1027 }
1028
1029 static HRESULT WINAPI IWineD3DDeviceImpl_CreateCubeTexture(IWineD3DDevice *iface, UINT EdgeLength,
1030                                                     UINT Levels, DWORD Usage,
1031                                                     WINED3DFORMAT Format, WINED3DPOOL Pool,
1032                                                     IWineD3DCubeTexture **ppCubeTexture,
1033                                                     HANDLE *pSharedHandle, IUnknown *parent,
1034                                                     D3DCB_CREATESURFACEFN D3DCB_CreateSurface) {
1035
1036     IWineD3DDeviceImpl      *This = (IWineD3DDeviceImpl *)iface;
1037     IWineD3DCubeTextureImpl *object; /** NOTE: impl ref allowed since this is a create function **/
1038     unsigned int             i, j;
1039     UINT                     tmpW;
1040     HRESULT                  hr;
1041     unsigned int pow2EdgeLength;
1042     const struct GlPixelFormatDesc *glDesc;
1043     getFormatDescEntry(Format, &GLINFO_LOCATION, &glDesc);
1044
1045     /* TODO: It should only be possible to create textures for formats
1046              that are reported as supported */
1047     if (WINED3DFMT_UNKNOWN >= Format) {
1048         WARN("(%p) : Texture cannot be created with a format of WINED3DFMT_UNKNOWN\n", This);
1049         return WINED3DERR_INVALIDCALL;
1050     }
1051
1052     if (!GL_SUPPORT(ARB_TEXTURE_CUBE_MAP) && Pool != WINED3DPOOL_SCRATCH) {
1053         WARN("(%p) : Tried to create not supported cube texture\n", This);
1054         return WINED3DERR_INVALIDCALL;
1055     }
1056
1057     D3DCREATERESOURCEOBJECTINSTANCE(object, CubeTexture, WINED3DRTYPE_CUBETEXTURE, 0);
1058     D3DINITIALIZEBASETEXTURE(object->baseTexture);
1059
1060     TRACE("(%p) Create Cube Texture\n", This);
1061
1062     /* Find the nearest pow2 match */
1063     pow2EdgeLength = 1;
1064     while (pow2EdgeLength < EdgeLength) pow2EdgeLength <<= 1;
1065
1066     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
1067         /* Precalculated scaling for 'faked' non power of two texture coords */
1068         object->baseTexture.pow2Matrix[ 0] = 1.0;
1069         object->baseTexture.pow2Matrix[ 5] = 1.0;
1070         object->baseTexture.pow2Matrix[10] = 1.0;
1071         object->baseTexture.pow2Matrix[15] = 1.0;
1072     } else {
1073         /* Precalculated scaling for 'faked' non power of two texture coords */
1074         object->baseTexture.pow2Matrix[ 0] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1075         object->baseTexture.pow2Matrix[ 5] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1076         object->baseTexture.pow2Matrix[10] = ((float)EdgeLength) / ((float)pow2EdgeLength);
1077         object->baseTexture.pow2Matrix[15] = 1.0;
1078     }
1079
1080     if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING) {
1081         object->baseTexture.minMipLookup = minMipLookup;
1082         object->baseTexture.magLookup    = magLookup;
1083     } else {
1084         object->baseTexture.minMipLookup = minMipLookup_noFilter;
1085         object->baseTexture.magLookup    = magLookup_noFilter;
1086     }
1087
1088     /* Calculate levels for mip mapping */
1089     if (Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
1090         if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
1091             WARN("No mipmap generation support, returning D3DERR_INVALIDCALL\n");
1092             HeapFree(GetProcessHeap(), 0, object);
1093             *ppCubeTexture = NULL;
1094
1095             return WINED3DERR_INVALIDCALL;
1096         }
1097         if(Levels > 1) {
1098             WARN("D3DUSAGE_AUTOGENMIPMAP is set, and level count > 1, returning D3DERR_INVALIDCALL\n");
1099             HeapFree(GetProcessHeap(), 0, object);
1100             *ppCubeTexture = NULL;
1101
1102             return WINED3DERR_INVALIDCALL;
1103         }
1104         object->baseTexture.levels = 1;
1105     } else if (Levels == 0) {
1106         object->baseTexture.levels = wined3d_log2i(EdgeLength) + 1;
1107         TRACE("Calculated levels = %d\n", object->baseTexture.levels);
1108     }
1109
1110     /* Generate all the surfaces */
1111     tmpW = EdgeLength;
1112     for (i = 0; i < object->baseTexture.levels; i++) {
1113
1114         /* Create the 6 faces */
1115         for (j = 0; j < 6; j++) {
1116             static const GLenum cube_targets[6] = {
1117                 GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
1118                 GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
1119                 GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
1120                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
1121                 GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
1122                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
1123             };
1124
1125             hr=D3DCB_CreateSurface(This->parent, parent, tmpW, tmpW, Format, Usage, Pool,
1126                                    i /* Level */, j, &object->surfaces[j][i],pSharedHandle);
1127
1128             if(hr!= WINED3D_OK) {
1129                 /* clean up */
1130                 unsigned int k;
1131                 unsigned int l;
1132                 for (l = 0; l < j; l++) {
1133                     IWineD3DSurface_Release(object->surfaces[l][i]);
1134                 }
1135                 for (k = 0; k < i; k++) {
1136                     for (l = 0; l < 6; l++) {
1137                         IWineD3DSurface_Release(object->surfaces[l][k]);
1138                     }
1139                 }
1140
1141                 FIXME("(%p) Failed to create surface\n",object);
1142                 HeapFree(GetProcessHeap(),0,object);
1143                 *ppCubeTexture = NULL;
1144                 return hr;
1145             }
1146             IWineD3DSurface_SetContainer(object->surfaces[j][i], (IWineD3DBase *)object);
1147             TRACE("Created surface level %d @ %p,\n", i, object->surfaces[j][i]);
1148             surface_set_texture_target(object->surfaces[j][i], cube_targets[j]);
1149         }
1150         tmpW = max(1, tmpW >> 1);
1151     }
1152     object->baseTexture.shader_color_fixup = glDesc->color_fixup;
1153
1154     TRACE("(%p) : Created Cube Texture %p\n", This, object);
1155     *ppCubeTexture = (IWineD3DCubeTexture *) object;
1156     return WINED3D_OK;
1157 }
1158
1159 static HRESULT WINAPI IWineD3DDeviceImpl_CreateQuery(IWineD3DDevice *iface, WINED3DQUERYTYPE Type, IWineD3DQuery **ppQuery, IUnknown* parent) {
1160     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1161     IWineD3DQueryImpl *object; /*NOTE: impl ref allowed since this is a create function */
1162     HRESULT hr = WINED3DERR_NOTAVAILABLE;
1163     const IWineD3DQueryVtbl *vtable;
1164
1165     /* Just a check to see if we support this type of query */
1166     switch(Type) {
1167     case WINED3DQUERYTYPE_OCCLUSION:
1168         TRACE("(%p) occlusion query\n", This);
1169         if (GL_SUPPORT(ARB_OCCLUSION_QUERY))
1170             hr = WINED3D_OK;
1171         else
1172             WARN("Unsupported in local OpenGL implementation: ARB_OCCLUSION_QUERY/NV_OCCLUSION_QUERY\n");
1173
1174         vtable = &IWineD3DOcclusionQuery_Vtbl;
1175         break;
1176
1177     case WINED3DQUERYTYPE_EVENT:
1178         if(!(GL_SUPPORT(NV_FENCE) || GL_SUPPORT(APPLE_FENCE) )) {
1179             /* Half-Life 2 needs this query. It does not render the main menu correctly otherwise
1180              * Pretend to support it, faking this query does not do much harm except potentially lowering performance
1181              */
1182             FIXME("(%p) Event query: Unimplemented, but pretending to be supported\n", This);
1183         }
1184         vtable = &IWineD3DEventQuery_Vtbl;
1185         hr = WINED3D_OK;
1186         break;
1187
1188     case WINED3DQUERYTYPE_VCACHE:
1189     case WINED3DQUERYTYPE_RESOURCEMANAGER:
1190     case WINED3DQUERYTYPE_VERTEXSTATS:
1191     case WINED3DQUERYTYPE_TIMESTAMP:
1192     case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
1193     case WINED3DQUERYTYPE_TIMESTAMPFREQ:
1194     case WINED3DQUERYTYPE_PIPELINETIMINGS:
1195     case WINED3DQUERYTYPE_INTERFACETIMINGS:
1196     case WINED3DQUERYTYPE_VERTEXTIMINGS:
1197     case WINED3DQUERYTYPE_PIXELTIMINGS:
1198     case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
1199     case WINED3DQUERYTYPE_CACHEUTILIZATION:
1200     default:
1201         /* Use the base Query vtable until we have a special one for each query */
1202         vtable = &IWineD3DQuery_Vtbl;
1203         FIXME("(%p) Unhandled query type %d\n", This, Type);
1204     }
1205     if(NULL == ppQuery || hr != WINED3D_OK) {
1206         return hr;
1207     }
1208
1209     D3DCREATEOBJECTINSTANCE(object, Query)
1210     object->lpVtbl       = vtable;
1211     object->type         = Type;
1212     object->state        = QUERY_CREATED;
1213     /* allocated the 'extended' data based on the type of query requested */
1214     switch(Type){
1215     case WINED3DQUERYTYPE_OCCLUSION:
1216         object->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineQueryOcclusionData));
1217         ((WineQueryOcclusionData *)(object->extendedData))->ctx = This->activeContext;
1218
1219         if(GL_SUPPORT(ARB_OCCLUSION_QUERY)) {
1220             TRACE("(%p) Allocating data for an occlusion query\n", This);
1221
1222             ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1223             ENTER_GL();
1224             GL_EXTCALL(glGenQueriesARB(1, &((WineQueryOcclusionData *)(object->extendedData))->queryId));
1225             LEAVE_GL();
1226             break;
1227         }
1228     case WINED3DQUERYTYPE_EVENT:
1229         object->extendedData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineQueryEventData));
1230         ((WineQueryEventData *)(object->extendedData))->ctx = This->activeContext;
1231
1232         ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1233         ENTER_GL();
1234         if(GL_SUPPORT(APPLE_FENCE)) {
1235             GL_EXTCALL(glGenFencesAPPLE(1, &((WineQueryEventData *)(object->extendedData))->fenceId));
1236             checkGLcall("glGenFencesAPPLE");
1237         } else if(GL_SUPPORT(NV_FENCE)) {
1238             GL_EXTCALL(glGenFencesNV(1, &((WineQueryEventData *)(object->extendedData))->fenceId));
1239             checkGLcall("glGenFencesNV");
1240         }
1241         LEAVE_GL();
1242         break;
1243
1244     case WINED3DQUERYTYPE_VCACHE:
1245     case WINED3DQUERYTYPE_RESOURCEMANAGER:
1246     case WINED3DQUERYTYPE_VERTEXSTATS:
1247     case WINED3DQUERYTYPE_TIMESTAMP:
1248     case WINED3DQUERYTYPE_TIMESTAMPDISJOINT:
1249     case WINED3DQUERYTYPE_TIMESTAMPFREQ:
1250     case WINED3DQUERYTYPE_PIPELINETIMINGS:
1251     case WINED3DQUERYTYPE_INTERFACETIMINGS:
1252     case WINED3DQUERYTYPE_VERTEXTIMINGS:
1253     case WINED3DQUERYTYPE_PIXELTIMINGS:
1254     case WINED3DQUERYTYPE_BANDWIDTHTIMINGS:
1255     case WINED3DQUERYTYPE_CACHEUTILIZATION:
1256     default:
1257         object->extendedData = 0;
1258         FIXME("(%p) Unhandled query type %d\n",This , Type);
1259     }
1260     TRACE("(%p) : Created Query %p\n", This, object);
1261     return WINED3D_OK;
1262 }
1263
1264 /*****************************************************************************
1265  * IWineD3DDeviceImpl_SetupFullscreenWindow
1266  *
1267  * Helper function that modifies a HWND's Style and ExStyle for proper
1268  * fullscreen use.
1269  *
1270  * Params:
1271  *  iface: Pointer to the IWineD3DDevice interface
1272  *  window: Window to setup
1273  *
1274  *****************************************************************************/
1275 static LONG fullscreen_style(LONG orig_style) {
1276     LONG style = orig_style;
1277     style &= ~WS_CAPTION;
1278     style &= ~WS_THICKFRAME;
1279
1280     /* Make sure the window is managed, otherwise we won't get keyboard input */
1281     style |= WS_POPUP | WS_SYSMENU;
1282
1283     return style;
1284 }
1285
1286 static LONG fullscreen_exStyle(LONG orig_exStyle) {
1287     LONG exStyle = orig_exStyle;
1288
1289     /* Filter out window decorations */
1290     exStyle &= ~WS_EX_WINDOWEDGE;
1291     exStyle &= ~WS_EX_CLIENTEDGE;
1292
1293     return exStyle;
1294 }
1295
1296 static void IWineD3DDeviceImpl_SetupFullscreenWindow(IWineD3DDevice *iface, HWND window, UINT w, UINT h) {
1297     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1298
1299     LONG style, exStyle;
1300     /* Don't do anything if an original style is stored.
1301      * That shouldn't happen
1302      */
1303     TRACE("(%p): Setting up window %p for exclusive mode\n", This, window);
1304     if (This->style || This->exStyle) {
1305         ERR("(%p): Want to change the window parameters of HWND %p, but "
1306             "another style is stored for restoration afterwards\n", This, window);
1307     }
1308
1309     /* Get the parameters and save them */
1310     style = GetWindowLongW(window, GWL_STYLE);
1311     exStyle = GetWindowLongW(window, GWL_EXSTYLE);
1312     This->style = style;
1313     This->exStyle = exStyle;
1314
1315     style = fullscreen_style(style);
1316     exStyle = fullscreen_exStyle(exStyle);
1317
1318     TRACE("Old style was %08x,%08x, setting to %08x,%08x\n",
1319           This->style, This->exStyle, style, exStyle);
1320
1321     SetWindowLongW(window, GWL_STYLE, style);
1322     SetWindowLongW(window, GWL_EXSTYLE, exStyle);
1323
1324     /* Inform the window about the update. */
1325     SetWindowPos(window, HWND_TOP, 0, 0,
1326                  w, h, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
1327 }
1328
1329 /*****************************************************************************
1330  * IWineD3DDeviceImpl_RestoreWindow
1331  *
1332  * Helper function that restores a windows' properties when taking it out
1333  * of fullscreen mode
1334  *
1335  * Params:
1336  *  iface: Pointer to the IWineD3DDevice interface
1337  *  window: Window to setup
1338  *
1339  *****************************************************************************/
1340 static void IWineD3DDeviceImpl_RestoreWindow(IWineD3DDevice *iface, HWND window) {
1341     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1342     LONG style, exStyle;
1343
1344     /* This could be a DDSCL_NORMAL -> DDSCL_NORMAL
1345      * switch, do nothing
1346      */
1347     if (!This->style && !This->exStyle) return;
1348
1349     TRACE("(%p): Restoring window settings of window %p to %08x, %08x\n",
1350           This, window, This->style, This->exStyle);
1351
1352     style = GetWindowLongW(window, GWL_STYLE);
1353     exStyle = GetWindowLongW(window, GWL_EXSTYLE);
1354
1355     /* Only restore the style if the application didn't modify it during the fullscreen phase.
1356      * Some applications change it before calling Reset() when switching between windowed and
1357      * fullscreen modes(HL2), some depend on the original style(Eve Online)
1358      */
1359     if(style == fullscreen_style(This->style) &&
1360        exStyle == fullscreen_style(This->exStyle)) {
1361         SetWindowLongW(window, GWL_STYLE, This->style);
1362         SetWindowLongW(window, GWL_EXSTYLE, This->exStyle);
1363     }
1364
1365     /* Delete the old values */
1366     This->style = 0;
1367     This->exStyle = 0;
1368
1369     /* Inform the window about the update */
1370     SetWindowPos(window, 0 /* InsertAfter, ignored */,
1371                  0, 0, 0, 0, /* Pos, Size, ignored */
1372                  SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
1373 }
1374
1375 /* example at http://www.fairyengine.com/articles/dxmultiviews.htm */
1376 static HRESULT WINAPI IWineD3DDeviceImpl_CreateSwapChain(IWineD3DDevice* iface,
1377         WINED3DPRESENT_PARAMETERS* pPresentationParameters, IWineD3DSwapChain** ppSwapChain,
1378         IUnknown* parent, D3DCB_CREATERENDERTARGETFN D3DCB_CreateRenderTarget,
1379         D3DCB_CREATEDEPTHSTENCILSURFACEFN D3DCB_CreateDepthStencil, WINED3DSURFTYPE surface_type)
1380 {
1381     IWineD3DDeviceImpl      *This = (IWineD3DDeviceImpl *)iface;
1382
1383     HDC                     hDc;
1384     IWineD3DSwapChainImpl  *object; /** NOTE: impl ref allowed since this is a create function **/
1385     HRESULT                 hr;
1386     IUnknown               *bufferParent;
1387     BOOL                    displaymode_set = FALSE;
1388     WINED3DDISPLAYMODE      Mode;
1389     const StaticPixelFormatDesc *formatDesc;
1390
1391     TRACE("(%p) : Created Additional Swap Chain\n", This);
1392
1393    /** FIXME: Test under windows to find out what the life cycle of a swap chain is,
1394    * does a device hold a reference to a swap chain giving them a lifetime of the device
1395    * or does the swap chain notify the device of its destruction.
1396     *******************************/
1397
1398     /* Check the params */
1399     if(pPresentationParameters->BackBufferCount > WINED3DPRESENT_BACK_BUFFER_MAX) {
1400         ERR("App requested %d back buffers, this is not supported for now\n", pPresentationParameters->BackBufferCount);
1401         return WINED3DERR_INVALIDCALL;
1402     } else if (pPresentationParameters->BackBufferCount > 1) {
1403         FIXME("The app requests more than one back buffer, this can't be supported properly. Please configure the application to use double buffering(=1 back buffer) if possible\n");
1404     }
1405
1406     D3DCREATEOBJECTINSTANCE(object, SwapChain)
1407     switch(surface_type) {
1408         case SURFACE_GDI:
1409             object->lpVtbl = &IWineGDISwapChain_Vtbl;
1410             break;
1411         case SURFACE_OPENGL:
1412             object->lpVtbl = &IWineD3DSwapChain_Vtbl;
1413             break;
1414         case SURFACE_UNKNOWN:
1415             FIXME("Caller tried to create a SURFACE_UNKNOWN swapchain\n");
1416             return WINED3DERR_INVALIDCALL;
1417     }
1418
1419     /*********************
1420     * Lookup the window Handle and the relating X window handle
1421     ********************/
1422
1423     /* Setup hwnd we are using, plus which display this equates to */
1424     object->win_handle = pPresentationParameters->hDeviceWindow;
1425     if (!object->win_handle) {
1426         object->win_handle = This->createParms.hFocusWindow;
1427     }
1428     if(!pPresentationParameters->Windowed && object->win_handle) {
1429         IWineD3DDeviceImpl_SetupFullscreenWindow(iface, object->win_handle,
1430                                                  pPresentationParameters->BackBufferWidth,
1431                                                  pPresentationParameters->BackBufferHeight);
1432     }
1433
1434     hDc                = GetDC(object->win_handle);
1435     TRACE("Using hDc %p\n", hDc);
1436
1437     if (NULL == hDc) {
1438         WARN("Failed to get a HDc for Window %p\n", object->win_handle);
1439         return WINED3DERR_NOTAVAILABLE;
1440     }
1441
1442     /* Get info on the current display setup */
1443     IWineD3D_GetAdapterDisplayMode(This->wineD3D, This->adapter->num, &Mode);
1444     object->orig_width = Mode.Width;
1445     object->orig_height = Mode.Height;
1446     object->orig_fmt = Mode.Format;
1447     formatDesc  = getFormatDescEntry(Mode.Format, NULL, NULL);
1448
1449     /** MSDN: If Windowed is TRUE and either of the BackBufferWidth/Height values is zero,
1450      *  then the corresponding dimension of the client area of the hDeviceWindow
1451      *  (or the focus window, if hDeviceWindow is NULL) is taken.
1452       **********************/
1453
1454     if (pPresentationParameters->Windowed &&
1455         ((pPresentationParameters->BackBufferWidth == 0) ||
1456          (pPresentationParameters->BackBufferHeight == 0) ||
1457          (pPresentationParameters->BackBufferFormat == WINED3DFMT_UNKNOWN))) {
1458
1459         RECT Rect;
1460         GetClientRect(object->win_handle, &Rect);
1461
1462         if (pPresentationParameters->BackBufferWidth == 0) {
1463            pPresentationParameters->BackBufferWidth = Rect.right;
1464            TRACE("Updating width to %d\n", pPresentationParameters->BackBufferWidth);
1465         }
1466         if (pPresentationParameters->BackBufferHeight == 0) {
1467            pPresentationParameters->BackBufferHeight = Rect.bottom;
1468            TRACE("Updating height to %d\n", pPresentationParameters->BackBufferHeight);
1469         }
1470         if (pPresentationParameters->BackBufferFormat == WINED3DFMT_UNKNOWN) {
1471            pPresentationParameters->BackBufferFormat = object->orig_fmt;
1472            TRACE("Updating format to %s\n", debug_d3dformat(object->orig_fmt));
1473         }
1474     }
1475
1476     /* Put the correct figures in the presentation parameters */
1477     TRACE("Copying across presentation parameters\n");
1478     object->presentParms = *pPresentationParameters;
1479
1480     TRACE("calling rendertarget CB\n");
1481     hr = D3DCB_CreateRenderTarget(This->parent,
1482                              parent,
1483                              object->presentParms.BackBufferWidth,
1484                              object->presentParms.BackBufferHeight,
1485                              object->presentParms.BackBufferFormat,
1486                              object->presentParms.MultiSampleType,
1487                              object->presentParms.MultiSampleQuality,
1488                              TRUE /* Lockable */,
1489                              &object->frontBuffer,
1490                              NULL /* pShared (always null)*/);
1491     if (SUCCEEDED(hr)) {
1492         IWineD3DSurface_SetContainer(object->frontBuffer, (IWineD3DBase *)object);
1493         if(surface_type == SURFACE_OPENGL) {
1494             IWineD3DSurface_ModifyLocation(object->frontBuffer, SFLAG_INDRAWABLE, TRUE);
1495         }
1496     } else {
1497         ERR("Failed to create the front buffer\n");
1498         goto error;
1499     }
1500
1501    /*********************
1502    * Windowed / Fullscreen
1503    *******************/
1504
1505    /**
1506    * TODO: MSDN says that we are only allowed one fullscreen swapchain per device,
1507    * so we should really check to see if there is a fullscreen swapchain already
1508    * I think Windows and X have different ideas about fullscreen, does a single head count as full screen?
1509     **************************************/
1510
1511    if (!pPresentationParameters->Windowed) {
1512         WINED3DDISPLAYMODE mode;
1513
1514
1515         /* Change the display settings */
1516         mode.Width = pPresentationParameters->BackBufferWidth;
1517         mode.Height = pPresentationParameters->BackBufferHeight;
1518         mode.Format = pPresentationParameters->BackBufferFormat;
1519         mode.RefreshRate = pPresentationParameters->FullScreen_RefreshRateInHz;
1520
1521         IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
1522         displaymode_set = TRUE;
1523     }
1524
1525         /**
1526      * Create an opengl context for the display visual
1527      *  NOTE: the visual is chosen as the window is created and the glcontext cannot
1528      *     use different properties after that point in time. FIXME: How to handle when requested format
1529      *     doesn't match actual visual? Cannot choose one here - code removed as it ONLY works if the one
1530      *     it chooses is identical to the one already being used!
1531          **********************************/
1532     /** FIXME: Handle stencil appropriately via EnableAutoDepthStencil / AutoDepthStencilFormat **/
1533
1534     object->context = HeapAlloc(GetProcessHeap(), 0, sizeof(object->context));
1535     if(!object->context) {
1536         ERR("Failed to create the context array\n");
1537         hr = E_OUTOFMEMORY;
1538         goto error;
1539     }
1540     object->num_contexts = 1;
1541
1542     if(surface_type == SURFACE_OPENGL) {
1543         object->context[0] = CreateContext(This, (IWineD3DSurfaceImpl *) object->frontBuffer, object->win_handle, FALSE /* pbuffer */, pPresentationParameters);
1544         if (!object->context[0]) {
1545             ERR("Failed to create a new context\n");
1546             hr = WINED3DERR_NOTAVAILABLE;
1547             goto error;
1548         } else {
1549             TRACE("Context created (HWND=%p, glContext=%p)\n",
1550                 object->win_handle, object->context[0]->glCtx);
1551         }
1552     }
1553
1554    /*********************
1555    * Create the back, front and stencil buffers
1556    *******************/
1557     if(object->presentParms.BackBufferCount > 0) {
1558         UINT i;
1559
1560         object->backBuffer = HeapAlloc(GetProcessHeap(), 0, sizeof(IWineD3DSurface *) * object->presentParms.BackBufferCount);
1561         if(!object->backBuffer) {
1562             ERR("Out of memory\n");
1563             hr = E_OUTOFMEMORY;
1564             goto error;
1565         }
1566
1567         for(i = 0; i < object->presentParms.BackBufferCount; i++) {
1568             TRACE("calling rendertarget CB\n");
1569             hr = D3DCB_CreateRenderTarget(This->parent,
1570                                     parent,
1571                                     object->presentParms.BackBufferWidth,
1572                                     object->presentParms.BackBufferHeight,
1573                                     object->presentParms.BackBufferFormat,
1574                                     object->presentParms.MultiSampleType,
1575                                     object->presentParms.MultiSampleQuality,
1576                                     TRUE /* Lockable */,
1577                                     &object->backBuffer[i],
1578                                     NULL /* pShared (always null)*/);
1579             if(SUCCEEDED(hr)) {
1580                 IWineD3DSurface_SetContainer(object->backBuffer[i], (IWineD3DBase *)object);
1581             } else {
1582                 ERR("Cannot create new back buffer\n");
1583                 goto error;
1584             }
1585             if(surface_type == SURFACE_OPENGL) {
1586                 ENTER_GL();
1587                 glDrawBuffer(GL_BACK);
1588                 checkGLcall("glDrawBuffer(GL_BACK)");
1589                 LEAVE_GL();
1590             }
1591         }
1592     } else {
1593         object->backBuffer = NULL;
1594
1595         /* Single buffering - draw to front buffer */
1596         if(surface_type == SURFACE_OPENGL) {
1597             ENTER_GL();
1598             glDrawBuffer(GL_FRONT);
1599             checkGLcall("glDrawBuffer(GL_FRONT)");
1600             LEAVE_GL();
1601         }
1602     }
1603
1604     /* Under directX swapchains share the depth stencil, so only create one depth-stencil */
1605     if (pPresentationParameters->EnableAutoDepthStencil && surface_type == SURFACE_OPENGL) {
1606         TRACE("Creating depth stencil buffer\n");
1607         if (This->auto_depth_stencil_buffer == NULL ) {
1608             hr = D3DCB_CreateDepthStencil(This->parent,
1609                                     parent,
1610                                     object->presentParms.BackBufferWidth,
1611                                     object->presentParms.BackBufferHeight,
1612                                     object->presentParms.AutoDepthStencilFormat,
1613                                     object->presentParms.MultiSampleType,
1614                                     object->presentParms.MultiSampleQuality,
1615                                     FALSE /* FIXME: Discard */,
1616                                     &This->auto_depth_stencil_buffer,
1617                                     NULL /* pShared (always null)*/  );
1618             if (SUCCEEDED(hr)) {
1619                 IWineD3DSurface_SetContainer(This->auto_depth_stencil_buffer, 0);
1620             } else {
1621                 ERR("Failed to create the auto depth stencil\n");
1622                 goto error;
1623             }
1624         }
1625     }
1626
1627     IWineD3DSwapChain_GetGammaRamp((IWineD3DSwapChain *) object, &object->orig_gamma);
1628
1629     TRACE("Created swapchain %p\n", object);
1630     TRACE("FrontBuf @ %p, BackBuf @ %p, DepthStencil %d\n",object->frontBuffer, object->backBuffer ? object->backBuffer[0] : NULL, pPresentationParameters->EnableAutoDepthStencil);
1631     return WINED3D_OK;
1632
1633 error:
1634     if (displaymode_set) {
1635         DEVMODEW devmode;
1636         RECT     clip_rc;
1637
1638         SetRect(&clip_rc, 0, 0, object->orig_width, object->orig_height);
1639         ClipCursor(NULL);
1640
1641         /* Change the display settings */
1642         memset(&devmode, 0, sizeof(devmode));
1643         devmode.dmSize       = sizeof(devmode);
1644         devmode.dmFields     = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
1645         devmode.dmBitsPerPel = formatDesc->bpp * 8;
1646         devmode.dmPelsWidth  = object->orig_width;
1647         devmode.dmPelsHeight = object->orig_height;
1648         ChangeDisplaySettingsExW(This->adapter->DeviceName, &devmode, NULL, CDS_FULLSCREEN, NULL);
1649     }
1650
1651     if (object->backBuffer) {
1652         UINT i;
1653         for(i = 0; i < object->presentParms.BackBufferCount; i++) {
1654             if(object->backBuffer[i]) {
1655                 IWineD3DSurface_GetParent(object->backBuffer[i], &bufferParent);
1656                 IUnknown_Release(bufferParent); /* once for the get parent */
1657                 if (IUnknown_Release(bufferParent) > 0) {
1658                     FIXME("(%p) Something's still holding the back buffer\n",This);
1659                 }
1660             }
1661         }
1662         HeapFree(GetProcessHeap(), 0, object->backBuffer);
1663         object->backBuffer = NULL;
1664     }
1665     if(object->context && object->context[0])
1666         DestroyContext(This, object->context[0]);
1667     if(object->frontBuffer) {
1668         IWineD3DSurface_GetParent(object->frontBuffer, &bufferParent);
1669         IUnknown_Release(bufferParent); /* once for the get parent */
1670         if (IUnknown_Release(bufferParent) > 0) {
1671             FIXME("(%p) Something's still holding the front buffer\n",This);
1672         }
1673     }
1674     HeapFree(GetProcessHeap(), 0, object);
1675     return hr;
1676 }
1677
1678 /** NOTE: These are ahead of the other getters and setters to save using a forward declaration **/
1679 static UINT     WINAPI  IWineD3DDeviceImpl_GetNumberOfSwapChains(IWineD3DDevice *iface) {
1680     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1681     TRACE("(%p)\n", This);
1682
1683     return This->NumberOfSwapChains;
1684 }
1685
1686 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetSwapChain(IWineD3DDevice *iface, UINT iSwapChain, IWineD3DSwapChain **pSwapChain) {
1687     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1688     TRACE("(%p) : swapchain %d\n", This, iSwapChain);
1689
1690     if(iSwapChain < This->NumberOfSwapChains) {
1691         *pSwapChain = This->swapchains[iSwapChain];
1692         IWineD3DSwapChain_AddRef(*pSwapChain);
1693         TRACE("(%p) returning %p\n", This, *pSwapChain);
1694         return WINED3D_OK;
1695     } else {
1696         TRACE("Swapchain out of range\n");
1697         *pSwapChain = NULL;
1698         return WINED3DERR_INVALIDCALL;
1699     }
1700 }
1701
1702 /*****
1703  * Vertex Declaration
1704  *****/
1705 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppVertexDeclaration,
1706         IUnknown *parent, const WINED3DVERTEXELEMENT *elements, UINT element_count) {
1707     IWineD3DDeviceImpl            *This   = (IWineD3DDeviceImpl *)iface;
1708     IWineD3DVertexDeclarationImpl *object = NULL;
1709     HRESULT hr = WINED3D_OK;
1710
1711     TRACE("(%p) : directXVersion %u, elements %p, element_count %d, ppDecl=%p\n",
1712             This, ((IWineD3DImpl *)This->wineD3D)->dxVersion, elements, element_count, ppVertexDeclaration);
1713
1714     D3DCREATEOBJECTINSTANCE(object, VertexDeclaration)
1715
1716     hr = IWineD3DVertexDeclaration_SetDeclaration((IWineD3DVertexDeclaration *)object, elements, element_count);
1717     if(FAILED(hr)) {
1718         IWineD3DVertexDeclaration_Release((IWineD3DVertexDeclaration *)object);
1719         *ppVertexDeclaration = NULL;
1720     }
1721
1722     return hr;
1723 }
1724
1725 static unsigned int ConvertFvfToDeclaration(IWineD3DDeviceImpl *This, /* For the GL info, which has the type table */
1726                                             DWORD fvf, WINED3DVERTEXELEMENT** ppVertexElements) {
1727
1728     unsigned int idx, idx2;
1729     unsigned int offset;
1730     BOOL has_pos = (fvf & WINED3DFVF_POSITION_MASK) != 0;
1731     BOOL has_blend = (fvf & WINED3DFVF_XYZB5) > WINED3DFVF_XYZRHW;
1732     BOOL has_blend_idx = has_blend &&
1733        (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB5) ||
1734         (fvf & WINED3DFVF_LASTBETA_D3DCOLOR) ||
1735         (fvf & WINED3DFVF_LASTBETA_UBYTE4));
1736     BOOL has_normal = (fvf & WINED3DFVF_NORMAL) != 0;
1737     BOOL has_psize = (fvf & WINED3DFVF_PSIZE) != 0;
1738     BOOL has_diffuse = (fvf & WINED3DFVF_DIFFUSE) != 0;
1739     BOOL has_specular = (fvf & WINED3DFVF_SPECULAR) !=0;
1740
1741     DWORD num_textures = (fvf & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
1742     DWORD texcoords = (fvf & 0xFFFF0000) >> 16;
1743
1744     WINED3DVERTEXELEMENT end_element = WINED3DDECL_END();
1745     WINED3DVERTEXELEMENT *elements = NULL;
1746
1747     unsigned int size;
1748     DWORD num_blends = 1 + (((fvf & WINED3DFVF_XYZB5) - WINED3DFVF_XYZB1) >> 1);
1749     if (has_blend_idx) num_blends--;
1750
1751     /* Compute declaration size */
1752     size = has_pos + (has_blend && num_blends > 0) + has_blend_idx + has_normal +
1753            has_psize + has_diffuse + has_specular + num_textures + 1;
1754
1755     /* convert the declaration */
1756     elements = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WINED3DVERTEXELEMENT));
1757     if (!elements)
1758         return 0;
1759
1760     elements[size-1] = end_element;
1761     idx = 0;
1762     if (has_pos) {
1763         if (!has_blend && (fvf & WINED3DFVF_XYZRHW)) {
1764             elements[idx].Type = WINED3DDECLTYPE_FLOAT4;
1765             elements[idx].Usage = WINED3DDECLUSAGE_POSITIONT;
1766         }
1767         else {
1768             elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1769             elements[idx].Usage = WINED3DDECLUSAGE_POSITION;
1770         }
1771         elements[idx].UsageIndex = 0;
1772         idx++;
1773     }
1774     if (has_blend && (num_blends > 0)) {
1775         if (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR))
1776             elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1777         else {
1778             switch(num_blends) {
1779                 case 1: elements[idx].Type = WINED3DDECLTYPE_FLOAT1; break;
1780                 case 2: elements[idx].Type = WINED3DDECLTYPE_FLOAT2; break;
1781                 case 3: elements[idx].Type = WINED3DDECLTYPE_FLOAT3; break;
1782                 case 4: elements[idx].Type = WINED3DDECLTYPE_FLOAT4; break;
1783                 default:
1784                     ERR("Unexpected amount of blend values: %u\n", num_blends);
1785             }
1786         }
1787         elements[idx].Usage = WINED3DDECLUSAGE_BLENDWEIGHT;
1788         elements[idx].UsageIndex = 0;
1789         idx++;
1790     }
1791     if (has_blend_idx) {
1792         if (fvf & WINED3DFVF_LASTBETA_UBYTE4 ||
1793             (((fvf & WINED3DFVF_XYZB5) == WINED3DFVF_XYZB2) && (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)))
1794             elements[idx].Type = WINED3DDECLTYPE_UBYTE4;
1795         else if (fvf & WINED3DFVF_LASTBETA_D3DCOLOR)
1796             elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1797         else
1798             elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1799         elements[idx].Usage = WINED3DDECLUSAGE_BLENDINDICES;
1800         elements[idx].UsageIndex = 0;
1801         idx++;
1802     }
1803     if (has_normal) {
1804         elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1805         elements[idx].Usage = WINED3DDECLUSAGE_NORMAL;
1806         elements[idx].UsageIndex = 0;
1807         idx++;
1808     }
1809     if (has_psize) {
1810         elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1811         elements[idx].Usage = WINED3DDECLUSAGE_PSIZE;
1812         elements[idx].UsageIndex = 0;
1813         idx++;
1814     }
1815     if (has_diffuse) {
1816         elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1817         elements[idx].Usage = WINED3DDECLUSAGE_COLOR;
1818         elements[idx].UsageIndex = 0;
1819         idx++;
1820     }
1821     if (has_specular) {
1822         elements[idx].Type = WINED3DDECLTYPE_D3DCOLOR;
1823         elements[idx].Usage = WINED3DDECLUSAGE_COLOR;
1824         elements[idx].UsageIndex = 1;
1825         idx++;
1826     }
1827     for (idx2 = 0; idx2 < num_textures; idx2++) {
1828         unsigned int numcoords = (texcoords >> (idx2*2)) & 0x03;
1829         switch (numcoords) {
1830             case WINED3DFVF_TEXTUREFORMAT1:
1831                 elements[idx].Type = WINED3DDECLTYPE_FLOAT1;
1832                 break;
1833             case WINED3DFVF_TEXTUREFORMAT2:
1834                 elements[idx].Type = WINED3DDECLTYPE_FLOAT2;
1835                 break;
1836             case WINED3DFVF_TEXTUREFORMAT3:
1837                 elements[idx].Type = WINED3DDECLTYPE_FLOAT3;
1838                 break;
1839             case WINED3DFVF_TEXTUREFORMAT4:
1840                 elements[idx].Type = WINED3DDECLTYPE_FLOAT4;
1841                 break;
1842         }
1843         elements[idx].Usage = WINED3DDECLUSAGE_TEXCOORD;
1844         elements[idx].UsageIndex = idx2;
1845         idx++;
1846     }
1847
1848     /* Now compute offsets, and initialize the rest of the fields */
1849     for (idx = 0, offset = 0; idx < size-1; idx++) {
1850         elements[idx].Stream = 0;
1851         elements[idx].Method = WINED3DDECLMETHOD_DEFAULT;
1852         elements[idx].Offset = offset;
1853         offset += WINED3D_ATR_SIZE(elements[idx].Type) * WINED3D_ATR_TYPESIZE(elements[idx].Type);
1854     }
1855
1856     *ppVertexElements = elements;
1857     return size;
1858 }
1859
1860 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppVertexDeclaration, IUnknown *Parent, DWORD Fvf) {
1861     WINED3DVERTEXELEMENT* elements = NULL;
1862     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1863     unsigned int size;
1864     DWORD hr;
1865
1866     size = ConvertFvfToDeclaration(This, Fvf, &elements);
1867     if (size == 0) return WINED3DERR_OUTOFVIDEOMEMORY;
1868
1869     hr = IWineD3DDevice_CreateVertexDeclaration(iface, ppVertexDeclaration, Parent, elements, size);
1870     HeapFree(GetProcessHeap(), 0, elements);
1871     if (hr != S_OK) return hr;
1872
1873     return WINED3D_OK;
1874 }
1875
1876 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVertexShader(IWineD3DDevice *iface, IWineD3DVertexDeclaration *vertex_declaration, CONST DWORD *pFunction, IWineD3DVertexShader **ppVertexShader, IUnknown *parent) {
1877     IWineD3DDeviceImpl       *This = (IWineD3DDeviceImpl *)iface;
1878     IWineD3DVertexShaderImpl *object;  /* NOTE: impl usage is ok, this is a create */
1879     HRESULT hr = WINED3D_OK;
1880
1881     if (!pFunction) return WINED3DERR_INVALIDCALL;
1882
1883     D3DCREATESHADEROBJECTINSTANCE(object, VertexShader)
1884     object->baseShader.shader_ins = IWineD3DVertexShaderImpl_shader_ins;
1885
1886     TRACE("(%p) : Created Vertex shader %p\n", This, *ppVertexShader);
1887
1888     if (vertex_declaration) {
1889         IWineD3DVertexShader_FakeSemantics(*ppVertexShader, vertex_declaration);
1890     }
1891
1892     hr = IWineD3DVertexShader_SetFunction(*ppVertexShader, pFunction);
1893
1894     if (WINED3D_OK != hr) {
1895         FIXME("(%p) : Failed to set the function, returning WINED3DERR_INVALIDCALL\n", iface);
1896         IWineD3DVertexShader_Release(*ppVertexShader);
1897         return WINED3DERR_INVALIDCALL;
1898     }
1899     list_add_head(&This->shaders, &object->baseShader.shader_list_entry);
1900
1901     return WINED3D_OK;
1902 }
1903
1904 static HRESULT WINAPI IWineD3DDeviceImpl_CreatePixelShader(IWineD3DDevice *iface, CONST DWORD *pFunction, IWineD3DPixelShader **ppPixelShader, IUnknown *parent) {
1905     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
1906     IWineD3DPixelShaderImpl *object; /* NOTE: impl allowed, this is a create */
1907     HRESULT hr = WINED3D_OK;
1908
1909     if (!pFunction) return WINED3DERR_INVALIDCALL;
1910
1911     D3DCREATESHADEROBJECTINSTANCE(object, PixelShader)
1912     object->baseShader.shader_ins = IWineD3DPixelShaderImpl_shader_ins;
1913     hr = IWineD3DPixelShader_SetFunction(*ppPixelShader, pFunction);
1914     if (WINED3D_OK == hr) {
1915         TRACE("(%p) : Created Pixel shader %p\n", This, *ppPixelShader);
1916         list_add_head(&This->shaders, &object->baseShader.shader_list_entry);
1917     } else {
1918         WARN("(%p) : Failed to create pixel shader\n", This);
1919     }
1920
1921     return hr;
1922 }
1923
1924 static HRESULT WINAPI IWineD3DDeviceImpl_CreatePalette(IWineD3DDevice *iface, DWORD Flags,
1925         const PALETTEENTRY *PalEnt, IWineD3DPalette **Palette, IUnknown *Parent)
1926 {
1927     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
1928     IWineD3DPaletteImpl *object;
1929     HRESULT hr;
1930     TRACE("(%p)->(%x, %p, %p, %p)\n", This, Flags, PalEnt, Palette, Parent);
1931
1932     /* Create the new object */
1933     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DPaletteImpl));
1934     if(!object) {
1935         ERR("Out of memory when allocating memory for a IWineD3DPalette implementation\n");
1936         return E_OUTOFMEMORY;
1937     }
1938
1939     object->lpVtbl = &IWineD3DPalette_Vtbl;
1940     object->ref = 1;
1941     object->Flags = Flags;
1942     object->parent = Parent;
1943     object->wineD3DDevice = This;
1944     object->palNumEntries = IWineD3DPaletteImpl_Size(Flags);
1945
1946     object->hpal = CreatePalette((const LOGPALETTE*)&(object->palVersion));
1947
1948     if(!object->hpal) {
1949         HeapFree( GetProcessHeap(), 0, object);
1950         return E_OUTOFMEMORY;
1951     }
1952
1953     hr = IWineD3DPalette_SetEntries((IWineD3DPalette *) object, 0, 0, IWineD3DPaletteImpl_Size(Flags), PalEnt);
1954     if(FAILED(hr)) {
1955         IWineD3DPalette_Release((IWineD3DPalette *) object);
1956         return hr;
1957     }
1958
1959     *Palette = (IWineD3DPalette *) object;
1960
1961     return WINED3D_OK;
1962 }
1963
1964 static void IWineD3DDeviceImpl_LoadLogo(IWineD3DDeviceImpl *This, const char *filename) {
1965     HBITMAP hbm;
1966     BITMAP bm;
1967     HRESULT hr;
1968     HDC dcb = NULL, dcs = NULL;
1969     WINEDDCOLORKEY colorkey;
1970
1971     hbm = (HBITMAP) LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
1972     if(hbm)
1973     {
1974         GetObjectA(hbm, sizeof(BITMAP), &bm);
1975         dcb = CreateCompatibleDC(NULL);
1976         if(!dcb) goto out;
1977         SelectObject(dcb, hbm);
1978     }
1979     else
1980     {
1981         /* Create a 32x32 white surface to indicate that wined3d is used, but the specified image
1982          * couldn't be loaded
1983          */
1984         memset(&bm, 0, sizeof(bm));
1985         bm.bmWidth = 32;
1986         bm.bmHeight = 32;
1987     }
1988
1989     hr = IWineD3DDevice_CreateSurface((IWineD3DDevice *) This, bm.bmWidth, bm.bmHeight, WINED3DFMT_R5G6B5,
1990                                       TRUE, FALSE, 0, &This->logo_surface, WINED3DRTYPE_SURFACE, 0,
1991                                       WINED3DPOOL_DEFAULT, WINED3DMULTISAMPLE_NONE, 0, NULL, SURFACE_OPENGL, NULL);
1992     if(FAILED(hr)) {
1993         ERR("Wine logo requested, but failed to create surface\n");
1994         goto out;
1995     }
1996
1997     if(dcb) {
1998         hr = IWineD3DSurface_GetDC(This->logo_surface, &dcs);
1999         if(FAILED(hr)) goto out;
2000         BitBlt(dcs, 0, 0, bm.bmWidth, bm.bmHeight, dcb, 0, 0, SRCCOPY);
2001         IWineD3DSurface_ReleaseDC(This->logo_surface, dcs);
2002
2003         colorkey.dwColorSpaceLowValue = 0;
2004         colorkey.dwColorSpaceHighValue = 0;
2005         IWineD3DSurface_SetColorKey(This->logo_surface, WINEDDCKEY_SRCBLT, &colorkey);
2006     } else {
2007         /* Fill the surface with a white color to show that wined3d is there */
2008         IWineD3DDevice_ColorFill((IWineD3DDevice *) This, This->logo_surface, NULL, 0xffffffff);
2009     }
2010
2011     out:
2012     if(dcb) {
2013         DeleteDC(dcb);
2014     }
2015     if(hbm) {
2016         DeleteObject(hbm);
2017     }
2018     return;
2019 }
2020
2021 static void create_dummy_textures(IWineD3DDeviceImpl *This) {
2022     unsigned int i;
2023     /* Under DirectX you can have texture stage operations even if no texture is
2024     bound, whereas opengl will only do texture operations when a valid texture is
2025     bound. We emulate this by creating dummy textures and binding them to each
2026     texture stage, but disable all stages by default. Hence if a stage is enabled
2027     then the default texture will kick in until replaced by a SetTexture call     */
2028     ENTER_GL();
2029
2030     if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
2031         /* The dummy texture does not have client storage backing */
2032         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
2033         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
2034     }
2035     for (i = 0; i < GL_LIMITS(textures); i++) {
2036         GLubyte white = 255;
2037
2038         /* Make appropriate texture active */
2039         GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
2040         checkGLcall("glActiveTextureARB");
2041
2042         /* Generate an opengl texture name */
2043         glGenTextures(1, &This->dummyTextureName[i]);
2044         checkGLcall("glGenTextures");
2045         TRACE("Dummy Texture %d given name %d\n", i, This->dummyTextureName[i]);
2046
2047         /* Generate a dummy 2d texture (not using 1d because they cause many
2048         * DRI drivers fall back to sw) */
2049         glBindTexture(GL_TEXTURE_2D, This->dummyTextureName[i]);
2050         checkGLcall("glBindTexture");
2051
2052         glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 1, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &white);
2053         checkGLcall("glTexImage2D");
2054     }
2055     if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
2056         /* Reenable because if supported it is enabled by default */
2057         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
2058         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
2059     }
2060
2061     LEAVE_GL();
2062 }
2063
2064 static HRESULT WINAPI IWineD3DDeviceImpl_Init3D(IWineD3DDevice *iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, D3DCB_CREATESWAPCHAIN D3DCB_CreateSwapChain) {
2065     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2066     IWineD3DSwapChainImpl *swapchain = NULL;
2067     HRESULT hr;
2068     DWORD state;
2069     unsigned int i;
2070
2071     TRACE("(%p)->(%p,%p)\n", This, pPresentationParameters, D3DCB_CreateSwapChain);
2072     if(This->d3d_initialized) return WINED3DERR_INVALIDCALL;
2073     if(!This->adapter->opengl) return WINED3DERR_INVALIDCALL;
2074
2075     /* TODO: Test if OpenGL is compiled in and loaded */
2076
2077     TRACE("(%p) : Creating stateblock\n", This);
2078     /* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
2079     hr = IWineD3DDevice_CreateStateBlock(iface,
2080                                          WINED3DSBT_INIT,
2081                                          (IWineD3DStateBlock **)&This->stateBlock,
2082                                          NULL);
2083     if (WINED3D_OK != hr) {   /* Note: No parent needed for initial internal stateblock */
2084         WARN("Failed to create stateblock\n");
2085         goto err_out;
2086     }
2087     TRACE("(%p) : Created stateblock (%p)\n", This, This->stateBlock);
2088     This->updateStateBlock = This->stateBlock;
2089     IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
2090
2091     This->render_targets = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *) * GL_LIMITS(buffers));
2092     This->draw_buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(GLenum) * GL_LIMITS(buffers));
2093
2094     This->NumberOfPalettes = 1;
2095     This->palettes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PALETTEENTRY*));
2096     if(!This->palettes || !This->render_targets || !This->draw_buffers) {
2097         ERR("Out of memory!\n");
2098         goto err_out;
2099     }
2100     This->palettes[0] = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2101     if(!This->palettes[0]) {
2102         ERR("Out of memory!\n");
2103         goto err_out;
2104     }
2105     for (i = 0; i < 256; ++i) {
2106         This->palettes[0][i].peRed   = 0xFF;
2107         This->palettes[0][i].peGreen = 0xFF;
2108         This->palettes[0][i].peBlue  = 0xFF;
2109         This->palettes[0][i].peFlags = 0xFF;
2110     }
2111     This->currentPalette = 0;
2112
2113     /* Initialize the texture unit mapping to a 1:1 mapping */
2114     for (state = 0; state < MAX_COMBINED_SAMPLERS; ++state) {
2115         if (state < GL_LIMITS(fragment_samplers)) {
2116             This->texUnitMap[state] = state;
2117             This->rev_tex_unit_map[state] = state;
2118         } else {
2119             This->texUnitMap[state] = -1;
2120             This->rev_tex_unit_map[state] = -1;
2121         }
2122     }
2123
2124     /* Setup the implicit swapchain */
2125     TRACE("Creating implicit swapchain\n");
2126     hr=D3DCB_CreateSwapChain(This->parent, pPresentationParameters, (IWineD3DSwapChain **)&swapchain);
2127     if (FAILED(hr) || !swapchain) {
2128         WARN("Failed to create implicit swapchain\n");
2129         goto err_out;
2130     }
2131
2132     This->NumberOfSwapChains = 1;
2133     This->swapchains = HeapAlloc(GetProcessHeap(), 0, This->NumberOfSwapChains * sizeof(IWineD3DSwapChain *));
2134     if(!This->swapchains) {
2135         ERR("Out of memory!\n");
2136         goto err_out;
2137     }
2138     This->swapchains[0] = (IWineD3DSwapChain *) swapchain;
2139
2140     if(swapchain->backBuffer && swapchain->backBuffer[0]) {
2141         TRACE("Setting rendertarget to %p\n", swapchain->backBuffer);
2142         This->render_targets[0] = swapchain->backBuffer[0];
2143         This->lastActiveRenderTarget = swapchain->backBuffer[0];
2144     }
2145     else {
2146         TRACE("Setting rendertarget to %p\n", swapchain->frontBuffer);
2147         This->render_targets[0] = swapchain->frontBuffer;
2148         This->lastActiveRenderTarget = swapchain->frontBuffer;
2149     }
2150     IWineD3DSurface_AddRef(This->render_targets[0]);
2151     This->activeContext = swapchain->context[0];
2152     This->lastThread = GetCurrentThreadId();
2153
2154     /* Depth Stencil support */
2155     This->stencilBufferTarget = This->auto_depth_stencil_buffer;
2156     if (NULL != This->stencilBufferTarget) {
2157         IWineD3DSurface_AddRef(This->stencilBufferTarget);
2158     }
2159
2160     hr = This->shader_backend->shader_alloc_private(iface);
2161     if(FAILED(hr)) {
2162         TRACE("Shader private data couldn't be allocated\n");
2163         goto err_out;
2164     }
2165     hr = This->frag_pipe->alloc_private(iface);
2166     if(FAILED(hr)) {
2167         TRACE("Fragment pipeline private data couldn't be allocated\n");
2168         goto err_out;
2169     }
2170     hr = This->blitter->alloc_private(iface);
2171     if(FAILED(hr)) {
2172         TRACE("Blitter private data couldn't be allocated\n");
2173         goto err_out;
2174     }
2175
2176     /* Set up some starting GL setup */
2177
2178     /* Setup all the devices defaults */
2179     IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *)This->stateBlock);
2180     create_dummy_textures(This);
2181
2182     ENTER_GL();
2183
2184     /* Initialize the current view state */
2185     This->view_ident = 1;
2186     This->contexts[0]->last_was_rhw = 0;
2187     glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights);
2188     checkGLcall("glGetIntegerv(GL_MAX_LIGHTS, &This->maxConcurrentLights)");
2189
2190     switch(wined3d_settings.offscreen_rendering_mode) {
2191         case ORM_FBO:
2192         case ORM_PBUFFER:
2193             This->offscreenBuffer = GL_BACK;
2194             break;
2195
2196         case ORM_BACKBUFFER:
2197         {
2198             if(This->activeContext->aux_buffers > 0) {
2199                 TRACE("Using auxilliary buffer for offscreen rendering\n");
2200                 This->offscreenBuffer = GL_AUX0;
2201             } else {
2202                 TRACE("Using back buffer for offscreen rendering\n");
2203                 This->offscreenBuffer = GL_BACK;
2204             }
2205         }
2206     }
2207
2208     TRACE("(%p) All defaults now set up, leaving Init3D with %p\n", This, This);
2209     LEAVE_GL();
2210
2211     /* Clear the screen */
2212     IWineD3DDevice_Clear((IWineD3DDevice *) This, 0, NULL,
2213                           WINED3DCLEAR_TARGET | pPresentationParameters->EnableAutoDepthStencil ? WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL : 0,
2214                           0x00, 1.0, 0);
2215
2216     This->d3d_initialized = TRUE;
2217
2218     if(wined3d_settings.logo) {
2219         IWineD3DDeviceImpl_LoadLogo(This, wined3d_settings.logo);
2220     }
2221     This->highest_dirty_ps_const = 0;
2222     This->highest_dirty_vs_const = 0;
2223     return WINED3D_OK;
2224
2225 err_out:
2226     HeapFree(GetProcessHeap(), 0, This->render_targets);
2227     HeapFree(GetProcessHeap(), 0, This->draw_buffers);
2228     HeapFree(GetProcessHeap(), 0, This->swapchains);
2229     This->NumberOfSwapChains = 0;
2230     if(This->palettes) {
2231         HeapFree(GetProcessHeap(), 0, This->palettes[0]);
2232         HeapFree(GetProcessHeap(), 0, This->palettes);
2233     }
2234     This->NumberOfPalettes = 0;
2235     if(swapchain) {
2236         IWineD3DSwapChain_Release( (IWineD3DSwapChain *) swapchain);
2237     }
2238     if(This->stateBlock) {
2239         IWineD3DStateBlock_Release((IWineD3DStateBlock *) This->stateBlock);
2240         This->stateBlock = NULL;
2241     }
2242     if (This->blit_priv) {
2243         This->blitter->free_private(iface);
2244     }
2245     if (This->fragment_priv) {
2246         This->frag_pipe->free_private(iface);
2247     }
2248     if (This->shader_priv) {
2249         This->shader_backend->shader_free_private(iface);
2250     }
2251     return hr;
2252 }
2253
2254 static HRESULT WINAPI IWineD3DDeviceImpl_InitGDI(IWineD3DDevice *iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters, D3DCB_CREATESWAPCHAIN D3DCB_CreateSwapChain) {
2255     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2256     IWineD3DSwapChainImpl *swapchain = NULL;
2257     HRESULT hr;
2258
2259     /* Setup the implicit swapchain */
2260     TRACE("Creating implicit swapchain\n");
2261     hr=D3DCB_CreateSwapChain(This->parent, pPresentationParameters, (IWineD3DSwapChain **)&swapchain);
2262     if (FAILED(hr) || !swapchain) {
2263         WARN("Failed to create implicit swapchain\n");
2264         goto err_out;
2265     }
2266
2267     This->NumberOfSwapChains = 1;
2268     This->swapchains = HeapAlloc(GetProcessHeap(), 0, This->NumberOfSwapChains * sizeof(IWineD3DSwapChain *));
2269     if(!This->swapchains) {
2270         ERR("Out of memory!\n");
2271         goto err_out;
2272     }
2273     This->swapchains[0] = (IWineD3DSwapChain *) swapchain;
2274     return WINED3D_OK;
2275
2276 err_out:
2277     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
2278     return hr;
2279 }
2280
2281 static HRESULT WINAPI IWineD3DDeviceImpl_Uninit3D(IWineD3DDevice *iface, D3DCB_DESTROYSURFACEFN D3DCB_DestroyDepthStencilSurface, D3DCB_DESTROYSWAPCHAINFN D3DCB_DestroySwapChain) {
2282     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2283     int sampler;
2284     UINT i;
2285     TRACE("(%p)\n", This);
2286
2287     if(!This->d3d_initialized) return WINED3DERR_INVALIDCALL;
2288
2289     /* I don't think that the interface guarantees that the device is destroyed from the same thread
2290      * it was created. Thus make sure a context is active for the glDelete* calls
2291      */
2292     ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
2293
2294     if(This->logo_surface) IWineD3DSurface_Release(This->logo_surface);
2295
2296     TRACE("Deleting high order patches\n");
2297     for(i = 0; i < PATCHMAP_SIZE; i++) {
2298         struct list *e1, *e2;
2299         struct WineD3DRectPatch *patch;
2300         LIST_FOR_EACH_SAFE(e1, e2, &This->patches[i]) {
2301             patch = LIST_ENTRY(e1, struct WineD3DRectPatch, entry);
2302             IWineD3DDevice_DeletePatch(iface, patch->Handle);
2303         }
2304     }
2305
2306     /* Delete the palette conversion shader if it is around */
2307     if(This->paletteConversionShader) {
2308         ENTER_GL();
2309         GL_EXTCALL(glDeleteProgramsARB(1, &This->paletteConversionShader));
2310         LEAVE_GL();
2311         This->paletteConversionShader = 0;
2312     }
2313
2314     /* Delete the pbuffer context if there is any */
2315     if(This->pbufferContext) DestroyContext(This, This->pbufferContext);
2316
2317     /* Delete the mouse cursor texture */
2318     if(This->cursorTexture) {
2319         ENTER_GL();
2320         glDeleteTextures(1, &This->cursorTexture);
2321         LEAVE_GL();
2322         This->cursorTexture = 0;
2323     }
2324
2325     for (sampler = 0; sampler < MAX_FRAGMENT_SAMPLERS; ++sampler) {
2326         IWineD3DDevice_SetTexture(iface, sampler, NULL);
2327     }
2328     for (sampler = 0; sampler < MAX_VERTEX_SAMPLERS; ++sampler) {
2329         IWineD3DDevice_SetTexture(iface, WINED3DVERTEXTEXTURESAMPLER0 + sampler, NULL);
2330     }
2331
2332     /* Destroy the depth blt resources, they will be invalid after the reset. Also free shader
2333      * private data, it might contain opengl pointers
2334      */
2335     if(This->depth_blt_texture) {
2336         glDeleteTextures(1, &This->depth_blt_texture);
2337         This->depth_blt_texture = 0;
2338     }
2339     if (This->depth_blt_rb) {
2340         GL_EXTCALL(glDeleteRenderbuffersEXT(1, &This->depth_blt_rb));
2341         This->depth_blt_rb = 0;
2342         This->depth_blt_rb_w = 0;
2343         This->depth_blt_rb_h = 0;
2344     }
2345
2346     /* Release the update stateblock */
2347     if(IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock) > 0){
2348         if(This->updateStateBlock != This->stateBlock)
2349             FIXME("(%p) Something's still holding the Update stateblock\n",This);
2350     }
2351     This->updateStateBlock = NULL;
2352
2353     { /* because were not doing proper internal refcounts releasing the primary state block
2354         causes recursion with the extra checks in ResourceReleased, to avoid this we have
2355         to set this->stateBlock = NULL; first */
2356         IWineD3DStateBlock *stateBlock = (IWineD3DStateBlock *)This->stateBlock;
2357         This->stateBlock = NULL;
2358
2359         /* Release the stateblock */
2360         if(IWineD3DStateBlock_Release(stateBlock) > 0){
2361             FIXME("(%p) Something's still holding the Update stateblock\n",This);
2362         }
2363     }
2364
2365     /* Destroy the shader backend. Note that this has to happen after all shaders are destroyed. */
2366     This->blitter->free_private(iface);
2367     This->frag_pipe->free_private(iface);
2368     This->shader_backend->shader_free_private(iface);
2369
2370     /* Release the buffers (with sanity checks)*/
2371     TRACE("Releasing the depth stencil buffer at %p\n", This->stencilBufferTarget);
2372     if(This->stencilBufferTarget != NULL && (IWineD3DSurface_Release(This->stencilBufferTarget) >0)){
2373         if(This->auto_depth_stencil_buffer != This->stencilBufferTarget)
2374             FIXME("(%p) Something's still holding the stencilBufferTarget\n",This);
2375     }
2376     This->stencilBufferTarget = NULL;
2377
2378     TRACE("Releasing the render target at %p\n", This->render_targets[0]);
2379     if(IWineD3DSurface_Release(This->render_targets[0]) >0){
2380           /* This check is a bit silly, it should be in swapchain_release FIXME("(%p) Something's still holding the renderTarget\n",This); */
2381     }
2382     TRACE("Setting rendertarget to NULL\n");
2383     This->render_targets[0] = NULL;
2384
2385     if (This->auto_depth_stencil_buffer) {
2386         if(D3DCB_DestroyDepthStencilSurface(This->auto_depth_stencil_buffer) > 0) {
2387             FIXME("(%p) Something's still holding the auto depth stencil buffer\n", This);
2388         }
2389         This->auto_depth_stencil_buffer = NULL;
2390     }
2391
2392     for(i=0; i < This->NumberOfSwapChains; i++) {
2393         TRACE("Releasing the implicit swapchain %d\n", i);
2394         if (D3DCB_DestroySwapChain(This->swapchains[i])  > 0) {
2395             FIXME("(%p) Something's still holding the implicit swapchain\n", This);
2396         }
2397     }
2398
2399     HeapFree(GetProcessHeap(), 0, This->swapchains);
2400     This->swapchains = NULL;
2401     This->NumberOfSwapChains = 0;
2402
2403     for (i = 0; i < This->NumberOfPalettes; i++) HeapFree(GetProcessHeap(), 0, This->palettes[i]);
2404     HeapFree(GetProcessHeap(), 0, This->palettes);
2405     This->palettes = NULL;
2406     This->NumberOfPalettes = 0;
2407
2408     HeapFree(GetProcessHeap(), 0, This->render_targets);
2409     HeapFree(GetProcessHeap(), 0, This->draw_buffers);
2410     This->render_targets = NULL;
2411     This->draw_buffers = NULL;
2412
2413     This->d3d_initialized = FALSE;
2414     return WINED3D_OK;
2415 }
2416
2417 static HRESULT WINAPI IWineD3DDeviceImpl_UninitGDI(IWineD3DDevice *iface, D3DCB_DESTROYSWAPCHAINFN D3DCB_DestroySwapChain) {
2418     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2419     unsigned int i;
2420
2421     for(i=0; i < This->NumberOfSwapChains; i++) {
2422         TRACE("Releasing the implicit swapchain %d\n", i);
2423         if (D3DCB_DestroySwapChain(This->swapchains[i])  > 0) {
2424             FIXME("(%p) Something's still holding the implicit swapchain\n", This);
2425         }
2426     }
2427
2428     HeapFree(GetProcessHeap(), 0, This->swapchains);
2429     This->swapchains = NULL;
2430     This->NumberOfSwapChains = 0;
2431     return WINED3D_OK;
2432 }
2433
2434 /* Enables thread safety in the wined3d device and its resources. Called by DirectDraw
2435  * from SetCooperativeLevel if DDSCL_MULTITHREADED is specified, and by d3d8/9 from
2436  * CreateDevice if D3DCREATE_MULTITHREADED is passed.
2437  *
2438  * There is no way to deactivate thread safety once it is enabled.
2439  */
2440 static void WINAPI IWineD3DDeviceImpl_SetMultithreaded(IWineD3DDevice *iface) {
2441     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
2442
2443     /*For now just store the flag(needed in case of ddraw) */
2444     This->createParms.BehaviorFlags |= WINED3DCREATE_MULTITHREADED;
2445
2446     return;
2447 }
2448
2449 static HRESULT WINAPI IWineD3DDeviceImpl_SetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain,
2450         const WINED3DDISPLAYMODE* pMode) {
2451     DEVMODEW devmode;
2452     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2453     LONG ret;
2454     const StaticPixelFormatDesc *formatDesc  = getFormatDescEntry(pMode->Format, NULL, NULL);
2455     RECT clip_rc;
2456
2457     TRACE("(%p)->(%d,%p) Mode=%dx%dx@%d, %s\n", This, iSwapChain, pMode, pMode->Width, pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
2458
2459     /* Resize the screen even without a window:
2460      * The app could have unset it with SetCooperativeLevel, but not called
2461      * RestoreDisplayMode first. Then the release will call RestoreDisplayMode,
2462      * but we don't have any hwnd
2463      */
2464
2465     memset(&devmode, 0, sizeof(devmode));
2466     devmode.dmSize = sizeof(devmode);
2467     devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
2468     devmode.dmBitsPerPel = formatDesc->bpp * 8;
2469     devmode.dmPelsWidth  = pMode->Width;
2470     devmode.dmPelsHeight = pMode->Height;
2471
2472     devmode.dmDisplayFrequency = pMode->RefreshRate;
2473     if (pMode->RefreshRate != 0)  {
2474         devmode.dmFields |= DM_DISPLAYFREQUENCY;
2475     }
2476
2477     /* Only change the mode if necessary */
2478     if( (This->ddraw_width == pMode->Width) &&
2479         (This->ddraw_height == pMode->Height) &&
2480         (This->ddraw_format == pMode->Format) &&
2481         (pMode->RefreshRate == 0) ) {
2482         return WINED3D_OK;
2483     }
2484
2485     ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL);
2486     if (ret != DISP_CHANGE_SUCCESSFUL) {
2487         if(devmode.dmDisplayFrequency != 0) {
2488             WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate\n");
2489             devmode.dmFields &= ~DM_DISPLAYFREQUENCY;
2490             devmode.dmDisplayFrequency = 0;
2491             ret = ChangeDisplaySettingsExW(NULL, &devmode, NULL, CDS_FULLSCREEN, NULL) != DISP_CHANGE_SUCCESSFUL;
2492         }
2493         if(ret != DISP_CHANGE_SUCCESSFUL) {
2494             return WINED3DERR_NOTAVAILABLE;
2495         }
2496     }
2497
2498     /* Store the new values */
2499     This->ddraw_width = pMode->Width;
2500     This->ddraw_height = pMode->Height;
2501     This->ddraw_format = pMode->Format;
2502
2503     /* And finally clip mouse to our screen */
2504     SetRect(&clip_rc, 0, 0, pMode->Width, pMode->Height);
2505     ClipCursor(&clip_rc);
2506
2507     return WINED3D_OK;
2508 }
2509
2510 static HRESULT WINAPI IWineD3DDeviceImpl_GetDirect3D(IWineD3DDevice *iface, IWineD3D **ppD3D) {
2511    IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2512    *ppD3D= This->wineD3D;
2513    TRACE("(%p) : wineD3D returning %p\n", This,  *ppD3D);
2514    IWineD3D_AddRef(*ppD3D);
2515    return WINED3D_OK;
2516 }
2517
2518 static UINT WINAPI IWineD3DDeviceImpl_GetAvailableTextureMem(IWineD3DDevice *iface) {
2519     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2520
2521     TRACE("(%p) : simulating %dMB, returning %dMB left\n",  This,
2522          (This->adapter->TextureRam/(1024*1024)),
2523          ((This->adapter->TextureRam - This->adapter->UsedTextureRam) / (1024*1024)));
2524     /* return simulated texture memory left */
2525     return (This->adapter->TextureRam - This->adapter->UsedTextureRam);
2526 }
2527
2528 /*****
2529  * Get / Set Stream Source
2530  *****/
2531 static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer* pStreamData, UINT OffsetInBytes, UINT Stride) {
2532         IWineD3DDeviceImpl       *This = (IWineD3DDeviceImpl *)iface;
2533     IWineD3DVertexBuffer     *oldSrc;
2534
2535     if (StreamNumber >= MAX_STREAMS) {
2536         WARN("Stream out of range %d\n", StreamNumber);
2537         return WINED3DERR_INVALIDCALL;
2538     } else if(OffsetInBytes & 0x3) {
2539         WARN("OffsetInBytes is not 4 byte aligned: %d\n", OffsetInBytes);
2540         return WINED3DERR_INVALIDCALL;
2541     }
2542
2543     oldSrc = This->updateStateBlock->streamSource[StreamNumber];
2544     TRACE("(%p) : StreamNo: %u, OldStream (%p), NewStream (%p), OffsetInBytes %u, NewStride %u\n", This, StreamNumber, oldSrc, pStreamData, OffsetInBytes, Stride);
2545
2546     This->updateStateBlock->changed.streamSource[StreamNumber] = TRUE;
2547
2548     if(oldSrc == pStreamData &&
2549        This->updateStateBlock->streamStride[StreamNumber] == Stride &&
2550        This->updateStateBlock->streamOffset[StreamNumber] == OffsetInBytes) {
2551        TRACE("Application is setting the old values over, nothing to do\n");
2552        return WINED3D_OK;
2553     }
2554
2555     This->updateStateBlock->streamSource[StreamNumber]         = pStreamData;
2556     if (pStreamData) {
2557         This->updateStateBlock->streamStride[StreamNumber]     = Stride;
2558         This->updateStateBlock->streamOffset[StreamNumber]     = OffsetInBytes;
2559     }
2560
2561     /* Handle recording of state blocks */
2562     if (This->isRecordingState) {
2563         TRACE("Recording... not performing anything\n");
2564         if(pStreamData) IWineD3DVertexBuffer_AddRef(pStreamData);
2565         if(oldSrc) IWineD3DVertexBuffer_Release(oldSrc);
2566         return WINED3D_OK;
2567     }
2568
2569     /* Need to do a getParent and pass the references up */
2570     /* MSDN says ..... When an application no longer holds a reference to this interface, the interface will automatically be freed.
2571     which suggests that we shouldn't be ref counting? and do need a _release on the stream source to reset the stream source
2572     so for now, just count internally   */
2573     if (pStreamData != NULL) {
2574         IWineD3DVertexBufferImpl *vbImpl = (IWineD3DVertexBufferImpl *) pStreamData;
2575         InterlockedIncrement(&vbImpl->bindCount);
2576         IWineD3DVertexBuffer_AddRef(pStreamData);
2577     }
2578     if (oldSrc != NULL) {
2579         InterlockedDecrement(&((IWineD3DVertexBufferImpl *) oldSrc)->bindCount);
2580         IWineD3DVertexBuffer_Release(oldSrc);
2581     }
2582
2583     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2584
2585     return WINED3D_OK;
2586 }
2587
2588 static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSource(IWineD3DDevice *iface, UINT StreamNumber,IWineD3DVertexBuffer** pStream, UINT *pOffset, UINT* pStride) {
2589     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2590
2591     TRACE("(%p) : StreamNo: %u, Stream (%p), Offset %u, Stride %u\n", This, StreamNumber,
2592            This->stateBlock->streamSource[StreamNumber],
2593            This->stateBlock->streamOffset[StreamNumber],
2594            This->stateBlock->streamStride[StreamNumber]);
2595
2596     if (StreamNumber >= MAX_STREAMS) {
2597         WARN("Stream out of range %d\n", StreamNumber);
2598         return WINED3DERR_INVALIDCALL;
2599     }
2600     *pStream = This->stateBlock->streamSource[StreamNumber];
2601     *pStride = This->stateBlock->streamStride[StreamNumber];
2602     if (pOffset) {
2603         *pOffset = This->stateBlock->streamOffset[StreamNumber];
2604     }
2605
2606     if (*pStream != NULL) {
2607         IWineD3DVertexBuffer_AddRef(*pStream); /* We have created a new reference to the VB */
2608     }
2609     return WINED3D_OK;
2610 }
2611
2612 static HRESULT WINAPI IWineD3DDeviceImpl_SetStreamSourceFreq(IWineD3DDevice *iface,  UINT StreamNumber, UINT Divider) {
2613     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2614     UINT oldFlags = This->updateStateBlock->streamFlags[StreamNumber];
2615     UINT oldFreq = This->updateStateBlock->streamFreq[StreamNumber];
2616
2617     /* Verify input at least in d3d9 this is invalid*/
2618     if( (Divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && (Divider & WINED3DSTREAMSOURCE_INDEXEDDATA)){
2619         WARN("INSTANCEDATA and INDEXEDDATA were set, returning D3DERR_INVALIDCALL\n");
2620         return WINED3DERR_INVALIDCALL;
2621     }
2622     if( (Divider & WINED3DSTREAMSOURCE_INSTANCEDATA) && StreamNumber == 0 ){
2623         WARN("INSTANCEDATA used on stream 0, returning D3DERR_INVALIDCALL\n");
2624         return WINED3DERR_INVALIDCALL;
2625     }
2626     if( Divider == 0 ){
2627         WARN("Divider is 0, returning D3DERR_INVALIDCALL\n");
2628         return WINED3DERR_INVALIDCALL;
2629     }
2630
2631     TRACE("(%p) StreamNumber(%d), Divider(%d)\n", This, StreamNumber, Divider);
2632     This->updateStateBlock->streamFlags[StreamNumber] = Divider & (WINED3DSTREAMSOURCE_INSTANCEDATA  | WINED3DSTREAMSOURCE_INDEXEDDATA );
2633
2634     This->updateStateBlock->changed.streamFreq[StreamNumber]  = TRUE;
2635     This->updateStateBlock->streamFreq[StreamNumber]          = Divider & 0x7FFFFF;
2636
2637     if(This->updateStateBlock->streamFreq[StreamNumber] != oldFreq ||
2638        This->updateStateBlock->streamFlags[StreamNumber] != oldFlags) {
2639         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
2640     }
2641
2642     return WINED3D_OK;
2643 }
2644
2645 static HRESULT WINAPI IWineD3DDeviceImpl_GetStreamSourceFreq(IWineD3DDevice *iface,  UINT StreamNumber, UINT* Divider) {
2646     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2647
2648     TRACE("(%p) StreamNumber(%d), Divider(%p)\n", This, StreamNumber, Divider);
2649     *Divider = This->updateStateBlock->streamFreq[StreamNumber] | This->updateStateBlock->streamFlags[StreamNumber];
2650
2651     TRACE("(%p) : returning %d\n", This, *Divider);
2652
2653     return WINED3D_OK;
2654 }
2655
2656 /*****
2657  * Get / Set & Multiply Transform
2658  *****/
2659 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE d3dts, CONST WINED3DMATRIX* lpmatrix) {
2660     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2661
2662     /* Most of this routine, comments included copied from ddraw tree initially: */
2663     TRACE("(%p) : Transform State=%s\n", This, debug_d3dtstype(d3dts));
2664
2665     /* Handle recording of state blocks */
2666     if (This->isRecordingState) {
2667         TRACE("Recording... not performing anything\n");
2668         This->updateStateBlock->changed.transform[d3dts] = TRUE;
2669         This->updateStateBlock->transforms[d3dts] = *lpmatrix;
2670         return WINED3D_OK;
2671     }
2672
2673     /*
2674      * If the new matrix is the same as the current one,
2675      * we cut off any further processing. this seems to be a reasonable
2676      * optimization because as was noticed, some apps (warcraft3 for example)
2677      * tend towards setting the same matrix repeatedly for some reason.
2678      *
2679      * From here on we assume that the new matrix is different, wherever it matters.
2680      */
2681     if (!memcmp(&This->stateBlock->transforms[d3dts].u.m[0][0], lpmatrix, sizeof(WINED3DMATRIX))) {
2682         TRACE("The app is setting the same matrix over again\n");
2683         return WINED3D_OK;
2684     } else {
2685         conv_mat(lpmatrix, &This->stateBlock->transforms[d3dts].u.m[0][0]);
2686     }
2687
2688     /*
2689        ScreenCoord = ProjectionMat * ViewMat * WorldMat * ObjectCoord
2690        where ViewMat = Camera space, WorldMat = world space.
2691
2692        In OpenGL, camera and world space is combined into GL_MODELVIEW
2693        matrix.  The Projection matrix stay projection matrix.
2694      */
2695
2696     /* Capture the times we can just ignore the change for now */
2697     if (d3dts == WINED3DTS_VIEW) { /* handle the VIEW matrix */
2698         This->view_ident = !memcmp(lpmatrix, identity, 16 * sizeof(float));
2699         /* Handled by the state manager */
2700     }
2701
2702     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TRANSFORM(d3dts));
2703     return WINED3D_OK;
2704
2705 }
2706 static HRESULT WINAPI IWineD3DDeviceImpl_GetTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE State, WINED3DMATRIX* pMatrix) {
2707     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2708     TRACE("(%p) : for Transform State %s\n", This, debug_d3dtstype(State));
2709     *pMatrix = This->stateBlock->transforms[State];
2710     return WINED3D_OK;
2711 }
2712
2713 static HRESULT WINAPI IWineD3DDeviceImpl_MultiplyTransform(IWineD3DDevice *iface, WINED3DTRANSFORMSTATETYPE State, CONST WINED3DMATRIX* pMatrix) {
2714     const WINED3DMATRIX *mat = NULL;
2715     WINED3DMATRIX temp;
2716
2717     /* Note: Using 'updateStateBlock' rather than 'stateblock' in the code
2718      * below means it will be recorded in a state block change, but it
2719      * works regardless where it is recorded.
2720      * If this is found to be wrong, change to StateBlock.
2721      */
2722     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2723     TRACE("(%p) : For state %s\n", This, debug_d3dtstype(State));
2724
2725     if (State < HIGHEST_TRANSFORMSTATE)
2726     {
2727         mat = &This->updateStateBlock->transforms[State];
2728     } else {
2729         FIXME("Unhandled transform state!!\n");
2730     }
2731
2732     multiply_matrix(&temp, mat, pMatrix);
2733
2734     /* Apply change via set transform - will reapply to eg. lights this way */
2735     return IWineD3DDeviceImpl_SetTransform(iface, State, &temp);
2736 }
2737
2738 /*****
2739  * Get / Set Light
2740  *****/
2741 /* Note lights are real special cases. Although the device caps state only eg. 8 are supported,
2742    you can reference any indexes you want as long as that number max are enabled at any
2743    one point in time! Therefore since the indexes can be anything, we need a hashmap of them.
2744    However, this causes stateblock problems. When capturing the state block, I duplicate the hashmap,
2745    but when recording, just build a chain pretty much of commands to be replayed.                  */
2746
2747 static HRESULT WINAPI IWineD3DDeviceImpl_SetLight(IWineD3DDevice *iface, DWORD Index, CONST WINED3DLIGHT* pLight) {
2748     float rho;
2749     PLIGHTINFOEL *object = NULL;
2750     UINT Hi = LIGHTMAP_HASHFUNC(Index);
2751     struct list *e;
2752
2753     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2754     TRACE("(%p) : Idx(%d), pLight(%p). Hash index is %d\n", This, Index, pLight, Hi);
2755
2756     /* Check the parameter range. Need for speed most wanted sets junk lights which confuse
2757      * the gl driver.
2758      */
2759     if(!pLight) {
2760         WARN("Light pointer = NULL, returning WINED3DERR_INVALIDCALL\n");
2761         return WINED3DERR_INVALIDCALL;
2762     }
2763
2764     switch(pLight->Type) {
2765         case WINED3DLIGHT_POINT:
2766         case WINED3DLIGHT_SPOT:
2767         case WINED3DLIGHT_PARALLELPOINT:
2768         case WINED3DLIGHT_GLSPOT:
2769             /* Incorrect attenuation values can cause the gl driver to crash. Happens with Need for speed
2770              * most wanted
2771              */
2772             if(pLight->Attenuation0 < 0.0 || pLight->Attenuation1 < 0.0 || pLight->Attenuation2 < 0.0) {
2773                 WARN("Attenuation is negative, returning WINED3DERR_INVALIDCALL\n");
2774                 return WINED3DERR_INVALIDCALL;
2775             }
2776             break;
2777
2778         case WINED3DLIGHT_DIRECTIONAL:
2779             /* Ignores attenuation */
2780             break;
2781
2782         default:
2783         WARN("Light type out of range, returning WINED3DERR_INVALIDCALL\n");
2784         return WINED3DERR_INVALIDCALL;
2785     }
2786
2787     LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2788         object = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2789         if(object->OriginalIndex == Index) break;
2790         object = NULL;
2791     }
2792
2793     if(!object) {
2794         TRACE("Adding new light\n");
2795         object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
2796         if(!object) {
2797             ERR("Out of memory error when allocating a light\n");
2798             return E_OUTOFMEMORY;
2799         }
2800         list_add_head(&This->updateStateBlock->lightMap[Hi], &object->entry);
2801         object->glIndex = -1;
2802         object->OriginalIndex = Index;
2803         object->changed = TRUE;
2804     }
2805
2806     /* Initialize the object */
2807     TRACE("Light %d setting to type %d, Diffuse(%f,%f,%f,%f), Specular(%f,%f,%f,%f), Ambient(%f,%f,%f,%f)\n", Index, pLight->Type,
2808           pLight->Diffuse.r, pLight->Diffuse.g, pLight->Diffuse.b, pLight->Diffuse.a,
2809           pLight->Specular.r, pLight->Specular.g, pLight->Specular.b, pLight->Specular.a,
2810           pLight->Ambient.r, pLight->Ambient.g, pLight->Ambient.b, pLight->Ambient.a);
2811     TRACE("... Pos(%f,%f,%f), Dirn(%f,%f,%f)\n", pLight->Position.x, pLight->Position.y, pLight->Position.z,
2812           pLight->Direction.x, pLight->Direction.y, pLight->Direction.z);
2813     TRACE("... Range(%f), Falloff(%f), Theta(%f), Phi(%f)\n", pLight->Range, pLight->Falloff, pLight->Theta, pLight->Phi);
2814
2815     /* Save away the information */
2816     object->OriginalParms = *pLight;
2817
2818     switch (pLight->Type) {
2819     case WINED3DLIGHT_POINT:
2820         /* Position */
2821         object->lightPosn[0] = pLight->Position.x;
2822         object->lightPosn[1] = pLight->Position.y;
2823         object->lightPosn[2] = pLight->Position.z;
2824         object->lightPosn[3] = 1.0f;
2825         object->cutoff = 180.0f;
2826         /* FIXME: Range */
2827         break;
2828
2829     case WINED3DLIGHT_DIRECTIONAL:
2830         /* Direction */
2831         object->lightPosn[0] = -pLight->Direction.x;
2832         object->lightPosn[1] = -pLight->Direction.y;
2833         object->lightPosn[2] = -pLight->Direction.z;
2834         object->lightPosn[3] = 0.0;
2835         object->exponent     = 0.0f;
2836         object->cutoff       = 180.0f;
2837         break;
2838
2839     case WINED3DLIGHT_SPOT:
2840         /* Position */
2841         object->lightPosn[0] = pLight->Position.x;
2842         object->lightPosn[1] = pLight->Position.y;
2843         object->lightPosn[2] = pLight->Position.z;
2844         object->lightPosn[3] = 1.0;
2845
2846         /* Direction */
2847         object->lightDirn[0] = pLight->Direction.x;
2848         object->lightDirn[1] = pLight->Direction.y;
2849         object->lightDirn[2] = pLight->Direction.z;
2850         object->lightDirn[3] = 1.0;
2851
2852         /*
2853          * opengl-ish and d3d-ish spot lights use too different models for the
2854          * light "intensity" as a function of the angle towards the main light direction,
2855          * so we only can approximate very roughly.
2856          * however spot lights are rather rarely used in games (if ever used at all).
2857          * furthermore if still used, probably nobody pays attention to such details.
2858          */
2859         if (pLight->Falloff == 0) {
2860             /* Falloff = 0 is easy, because d3d's and opengl's spot light equations have the
2861              * falloff resp. exponent parameter as an exponent, so the spot light lighting
2862              * will always be 1.0 for both of them, and we don't have to care for the
2863              * rest of the rather complex calculation
2864              */
2865             object->exponent = 0;
2866         } else {
2867             rho = pLight->Theta + (pLight->Phi - pLight->Theta)/(2*pLight->Falloff);
2868             if (rho < 0.0001) rho = 0.0001f;
2869             object->exponent = -0.3/log(cos(rho/2));
2870         }
2871         if (object->exponent > 128.0) {
2872                 object->exponent = 128.0;
2873         }
2874         object->cutoff = pLight->Phi*90/M_PI;
2875
2876         /* FIXME: Range */
2877         break;
2878
2879     default:
2880         FIXME("Unrecognized light type %d\n", pLight->Type);
2881     }
2882
2883     /* Update the live definitions if the light is currently assigned a glIndex */
2884     if (object->glIndex != -1 && !This->isRecordingState) {
2885         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(object->glIndex));
2886     }
2887     return WINED3D_OK;
2888 }
2889
2890 static HRESULT WINAPI IWineD3DDeviceImpl_GetLight(IWineD3DDevice *iface, DWORD Index, WINED3DLIGHT* pLight) {
2891     PLIGHTINFOEL *lightInfo = NULL;
2892     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2893     DWORD Hi = LIGHTMAP_HASHFUNC(Index);
2894     struct list *e;
2895     TRACE("(%p) : Idx(%d), pLight(%p)\n", This, Index, pLight);
2896
2897     LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi]) {
2898         lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2899         if(lightInfo->OriginalIndex == Index) break;
2900         lightInfo = NULL;
2901     }
2902
2903     if (lightInfo == NULL) {
2904         TRACE("Light information requested but light not defined\n");
2905         return WINED3DERR_INVALIDCALL;
2906     }
2907
2908     *pLight = lightInfo->OriginalParms;
2909     return WINED3D_OK;
2910 }
2911
2912 /*****
2913  * Get / Set Light Enable
2914  *   (Note for consistency, renamed d3dx function by adding the 'set' prefix)
2915  *****/
2916 static HRESULT WINAPI IWineD3DDeviceImpl_SetLightEnable(IWineD3DDevice *iface, DWORD Index, BOOL Enable) {
2917     PLIGHTINFOEL *lightInfo = NULL;
2918     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
2919     UINT Hi = LIGHTMAP_HASHFUNC(Index);
2920     struct list *e;
2921     TRACE("(%p) : Idx(%d), enable? %d\n", This, Index, Enable);
2922
2923     /* Tests show true = 128...not clear why */
2924     Enable = Enable? 128: 0;
2925
2926     LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2927         lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2928         if(lightInfo->OriginalIndex == Index) break;
2929         lightInfo = NULL;
2930     }
2931     TRACE("Found light: %p\n", lightInfo);
2932
2933     /* Special case - enabling an undefined light creates one with a strict set of parms! */
2934     if (lightInfo == NULL) {
2935
2936         TRACE("Light enabled requested but light not defined, so defining one!\n");
2937         IWineD3DDeviceImpl_SetLight(iface, Index, &WINED3D_default_light);
2938
2939         /* Search for it again! Should be fairly quick as near head of list */
2940         LIST_FOR_EACH(e, &This->updateStateBlock->lightMap[Hi]) {
2941             lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
2942             if(lightInfo->OriginalIndex == Index) break;
2943             lightInfo = NULL;
2944         }
2945         if (lightInfo == NULL) {
2946             FIXME("Adding default lights has failed dismally\n");
2947             return WINED3DERR_INVALIDCALL;
2948         }
2949     }
2950
2951     lightInfo->enabledChanged = TRUE;
2952     if(!Enable) {
2953         if(lightInfo->glIndex != -1) {
2954             if(!This->isRecordingState) {
2955                 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(lightInfo->glIndex));
2956             }
2957
2958             This->updateStateBlock->activeLights[lightInfo->glIndex] = NULL;
2959             lightInfo->glIndex = -1;
2960         } else {
2961             TRACE("Light already disabled, nothing to do\n");
2962         }
2963         lightInfo->enabled = FALSE;
2964     } else {
2965         lightInfo->enabled = TRUE;
2966         if (lightInfo->glIndex != -1) {
2967             /* nop */
2968             TRACE("Nothing to do as light was enabled\n");
2969         } else {
2970             int i;
2971             /* Find a free gl light */
2972             for(i = 0; i < This->maxConcurrentLights; i++) {
2973                 if(This->updateStateBlock->activeLights[i] == NULL) {
2974                     This->updateStateBlock->activeLights[i] = lightInfo;
2975                     lightInfo->glIndex = i;
2976                     break;
2977                 }
2978             }
2979             if(lightInfo->glIndex == -1) {
2980                 /* Our tests show that Windows returns D3D_OK in this situation, even with
2981                  * D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE devices. This
2982                  * is consistent among ddraw, d3d8 and d3d9. GetLightEnable returns TRUE
2983                  * as well for those lights.
2984                  *
2985                  * TODO: Test how this affects rendering
2986                  */
2987                 FIXME("Too many concurrently active lights\n");
2988                 return WINED3D_OK;
2989             }
2990
2991             /* i == lightInfo->glIndex */
2992             if(!This->isRecordingState) {
2993                 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i));
2994             }
2995         }
2996     }
2997
2998     return WINED3D_OK;
2999 }
3000
3001 static HRESULT WINAPI IWineD3DDeviceImpl_GetLightEnable(IWineD3DDevice *iface, DWORD Index,BOOL* pEnable) {
3002
3003     PLIGHTINFOEL *lightInfo = NULL;
3004     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3005     struct list *e;
3006     UINT Hi = LIGHTMAP_HASHFUNC(Index);
3007     TRACE("(%p) : for idx(%d)\n", This, Index);
3008
3009     LIST_FOR_EACH(e, &This->stateBlock->lightMap[Hi]) {
3010         lightInfo = LIST_ENTRY(e, PLIGHTINFOEL, entry);
3011         if(lightInfo->OriginalIndex == Index) break;
3012         lightInfo = NULL;
3013     }
3014
3015     if (lightInfo == NULL) {
3016         TRACE("Light enabled state requested but light not defined\n");
3017         return WINED3DERR_INVALIDCALL;
3018     }
3019     /* true is 128 according to SetLightEnable */
3020     *pEnable = lightInfo->enabled ? 128 : 0;
3021     return WINED3D_OK;
3022 }
3023
3024 /*****
3025  * Get / Set Clip Planes
3026  *****/
3027 static HRESULT WINAPI IWineD3DDeviceImpl_SetClipPlane(IWineD3DDevice *iface, DWORD Index, CONST float *pPlane) {
3028     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3029     TRACE("(%p) : for idx %d, %p\n", This, Index, pPlane);
3030
3031     /* Validate Index */
3032     if (Index >= GL_LIMITS(clipplanes)) {
3033         TRACE("Application has requested clipplane this device doesn't support\n");
3034         return WINED3DERR_INVALIDCALL;
3035     }
3036
3037     This->updateStateBlock->changed.clipplane[Index] = TRUE;
3038
3039     if(This->updateStateBlock->clipplane[Index][0] == pPlane[0] &&
3040        This->updateStateBlock->clipplane[Index][1] == pPlane[1] &&
3041        This->updateStateBlock->clipplane[Index][2] == pPlane[2] &&
3042        This->updateStateBlock->clipplane[Index][3] == pPlane[3]) {
3043         TRACE("Application is setting old values over, nothing to do\n");
3044         return WINED3D_OK;
3045     }
3046
3047     This->updateStateBlock->clipplane[Index][0] = pPlane[0];
3048     This->updateStateBlock->clipplane[Index][1] = pPlane[1];
3049     This->updateStateBlock->clipplane[Index][2] = pPlane[2];
3050     This->updateStateBlock->clipplane[Index][3] = pPlane[3];
3051
3052     /* Handle recording of state blocks */
3053     if (This->isRecordingState) {
3054         TRACE("Recording... not performing anything\n");
3055         return WINED3D_OK;
3056     }
3057
3058     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_CLIPPLANE(Index));
3059
3060     return WINED3D_OK;
3061 }
3062
3063 static HRESULT WINAPI IWineD3DDeviceImpl_GetClipPlane(IWineD3DDevice *iface, DWORD Index, float *pPlane) {
3064     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3065     TRACE("(%p) : for idx %d\n", This, Index);
3066
3067     /* Validate Index */
3068     if (Index >= GL_LIMITS(clipplanes)) {
3069         TRACE("Application has requested clipplane this device doesn't support\n");
3070         return WINED3DERR_INVALIDCALL;
3071     }
3072
3073     pPlane[0] = This->stateBlock->clipplane[Index][0];
3074     pPlane[1] = This->stateBlock->clipplane[Index][1];
3075     pPlane[2] = This->stateBlock->clipplane[Index][2];
3076     pPlane[3] = This->stateBlock->clipplane[Index][3];
3077     return WINED3D_OK;
3078 }
3079
3080 /*****
3081  * Get / Set Clip Plane Status
3082  *   WARNING: This code relies on the fact that D3DCLIPSTATUS8 == D3DCLIPSTATUS9
3083  *****/
3084 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetClipStatus(IWineD3DDevice *iface, CONST WINED3DCLIPSTATUS* pClipStatus) {
3085     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3086     FIXME("(%p) : stub\n", This);
3087     if (NULL == pClipStatus) {
3088       return WINED3DERR_INVALIDCALL;
3089     }
3090     This->updateStateBlock->clip_status.ClipUnion = pClipStatus->ClipUnion;
3091     This->updateStateBlock->clip_status.ClipIntersection = pClipStatus->ClipIntersection;
3092     return WINED3D_OK;
3093 }
3094
3095 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetClipStatus(IWineD3DDevice *iface, WINED3DCLIPSTATUS* pClipStatus) {
3096     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3097     FIXME("(%p) : stub\n", This);
3098     if (NULL == pClipStatus) {
3099       return WINED3DERR_INVALIDCALL;
3100     }
3101     pClipStatus->ClipUnion = This->updateStateBlock->clip_status.ClipUnion;
3102     pClipStatus->ClipIntersection = This->updateStateBlock->clip_status.ClipIntersection;
3103     return WINED3D_OK;
3104 }
3105
3106 /*****
3107  * Get / Set Material
3108  *****/
3109 static HRESULT WINAPI IWineD3DDeviceImpl_SetMaterial(IWineD3DDevice *iface, CONST WINED3DMATERIAL* pMaterial) {
3110     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3111
3112     This->updateStateBlock->changed.material = TRUE;
3113     This->updateStateBlock->material = *pMaterial;
3114
3115     /* Handle recording of state blocks */
3116     if (This->isRecordingState) {
3117         TRACE("Recording... not performing anything\n");
3118         return WINED3D_OK;
3119     }
3120
3121     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL);
3122     return WINED3D_OK;
3123 }
3124
3125 static HRESULT WINAPI IWineD3DDeviceImpl_GetMaterial(IWineD3DDevice *iface, WINED3DMATERIAL* pMaterial) {
3126     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3127     *pMaterial = This->updateStateBlock->material;
3128     TRACE("(%p) : Diffuse (%f,%f,%f,%f)\n", This, pMaterial->Diffuse.r, pMaterial->Diffuse.g,
3129         pMaterial->Diffuse.b, pMaterial->Diffuse.a);
3130     TRACE("(%p) : Ambient (%f,%f,%f,%f)\n", This, pMaterial->Ambient.r, pMaterial->Ambient.g,
3131         pMaterial->Ambient.b, pMaterial->Ambient.a);
3132     TRACE("(%p) : Specular (%f,%f,%f,%f)\n", This, pMaterial->Specular.r, pMaterial->Specular.g,
3133         pMaterial->Specular.b, pMaterial->Specular.a);
3134     TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g,
3135         pMaterial->Emissive.b, pMaterial->Emissive.a);
3136     TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
3137
3138     return WINED3D_OK;
3139 }
3140
3141 /*****
3142  * Get / Set Indices
3143  *****/
3144 static HRESULT WINAPI IWineD3DDeviceImpl_SetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer* pIndexData) {
3145     IWineD3DDeviceImpl  *This = (IWineD3DDeviceImpl *)iface;
3146     IWineD3DIndexBuffer *oldIdxs;
3147
3148     TRACE("(%p) : Setting to %p\n", This, pIndexData);
3149     oldIdxs = This->updateStateBlock->pIndexData;
3150
3151     This->updateStateBlock->changed.indices = TRUE;
3152     This->updateStateBlock->pIndexData = pIndexData;
3153
3154     /* Handle recording of state blocks */
3155     if (This->isRecordingState) {
3156         TRACE("Recording... not performing anything\n");
3157         if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
3158         if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
3159         return WINED3D_OK;
3160     }
3161
3162     if(oldIdxs != pIndexData) {
3163         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
3164         if(pIndexData) IWineD3DIndexBuffer_AddRef(pIndexData);
3165         if(oldIdxs) IWineD3DIndexBuffer_Release(oldIdxs);
3166     }
3167     return WINED3D_OK;
3168 }
3169
3170 static HRESULT WINAPI IWineD3DDeviceImpl_GetIndices(IWineD3DDevice *iface, IWineD3DIndexBuffer** ppIndexData) {
3171     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3172
3173     *ppIndexData = This->stateBlock->pIndexData;
3174
3175     /* up ref count on ppindexdata */
3176     if (*ppIndexData) {
3177         IWineD3DIndexBuffer_AddRef(*ppIndexData);
3178         TRACE("(%p) index data set to %p\n", This, ppIndexData);
3179     }else{
3180         TRACE("(%p) No index data set\n", This);
3181     }
3182     TRACE("Returning %p\n", *ppIndexData);
3183
3184     return WINED3D_OK;
3185 }
3186
3187 /* Method to offer d3d9 a simple way to set the base vertex index without messing with the index buffer */
3188 static HRESULT WINAPI IWineD3DDeviceImpl_SetBaseVertexIndex(IWineD3DDevice *iface, INT BaseIndex) {
3189     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3190     TRACE("(%p)->(%d)\n", This, BaseIndex);
3191
3192     if(This->updateStateBlock->baseVertexIndex == BaseIndex) {
3193         TRACE("Application is setting the old value over, nothing to do\n");
3194         return WINED3D_OK;
3195     }
3196
3197     This->updateStateBlock->baseVertexIndex = BaseIndex;
3198
3199     if (This->isRecordingState) {
3200         TRACE("Recording... not performing anything\n");
3201         return WINED3D_OK;
3202     }
3203     /* The base vertex index affects the stream sources */
3204     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
3205     return WINED3D_OK;
3206 }
3207
3208 static HRESULT WINAPI IWineD3DDeviceImpl_GetBaseVertexIndex(IWineD3DDevice *iface, INT* base_index) {
3209     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3210     TRACE("(%p) : base_index %p\n", This, base_index);
3211
3212     *base_index = This->stateBlock->baseVertexIndex;
3213
3214     TRACE("Returning %u\n", *base_index);
3215
3216     return WINED3D_OK;
3217 }
3218
3219 /*****
3220  * Get / Set Viewports
3221  *****/
3222 static HRESULT WINAPI IWineD3DDeviceImpl_SetViewport(IWineD3DDevice *iface, CONST WINED3DVIEWPORT* pViewport) {
3223     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3224
3225     TRACE("(%p)\n", This);
3226     This->updateStateBlock->changed.viewport = TRUE;
3227     This->updateStateBlock->viewport = *pViewport;
3228
3229     /* Handle recording of state blocks */
3230     if (This->isRecordingState) {
3231         TRACE("Recording... not performing anything\n");
3232         return WINED3D_OK;
3233     }
3234
3235     TRACE("(%p) : x=%d, y=%d, wid=%d, hei=%d, minz=%f, maxz=%f\n", This,
3236           pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ);
3237
3238     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
3239     return WINED3D_OK;
3240
3241 }
3242
3243 static HRESULT WINAPI IWineD3DDeviceImpl_GetViewport(IWineD3DDevice *iface, WINED3DVIEWPORT* pViewport) {
3244     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3245     TRACE("(%p)\n", This);
3246     *pViewport = This->stateBlock->viewport;
3247     return WINED3D_OK;
3248 }
3249
3250 /*****
3251  * Get / Set Render States
3252  * TODO: Verify against dx9 definitions
3253  *****/
3254 static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderState(IWineD3DDevice *iface, WINED3DRENDERSTATETYPE State, DWORD Value) {
3255
3256     IWineD3DDeviceImpl  *This     = (IWineD3DDeviceImpl *)iface;
3257     DWORD oldValue = This->stateBlock->renderState[State];
3258
3259     TRACE("(%p)->state = %s(%d), value = %d\n", This, debug_d3drenderstate(State), State, Value);
3260
3261     This->updateStateBlock->changed.renderState[State] = TRUE;
3262     This->updateStateBlock->renderState[State] = Value;
3263
3264     /* Handle recording of state blocks */
3265     if (This->isRecordingState) {
3266         TRACE("Recording... not performing anything\n");
3267         return WINED3D_OK;
3268     }
3269
3270     /* Compared here and not before the assignment to allow proper stateblock recording */
3271     if(Value == oldValue) {
3272         TRACE("Application is setting the old value over, nothing to do\n");
3273     } else {
3274         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(State));
3275     }
3276
3277     return WINED3D_OK;
3278 }
3279
3280 static HRESULT WINAPI IWineD3DDeviceImpl_GetRenderState(IWineD3DDevice *iface, WINED3DRENDERSTATETYPE State, DWORD *pValue) {
3281     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3282     TRACE("(%p) for State %d = %d\n", This, State, This->stateBlock->renderState[State]);
3283     *pValue = This->stateBlock->renderState[State];
3284     return WINED3D_OK;
3285 }
3286
3287 /*****
3288  * Get / Set Sampler States
3289  * TODO: Verify against dx9 definitions
3290  *****/
3291
3292 static HRESULT WINAPI IWineD3DDeviceImpl_SetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD Value) {
3293     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3294     DWORD oldValue;
3295
3296     TRACE("(%p) : Sampler %#x, Type %s (%#x), Value %#x\n",
3297             This, Sampler, debug_d3dsamplerstate(Type), Type, Value);
3298
3299     if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
3300         Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3301     }
3302
3303     if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
3304         ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
3305         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
3306     }
3307     /**
3308     * SetSampler is designed to allow for more than the standard up to 8 textures
3309     *  and Geforce has stopped supporting more than 6 standard textures in openGL.
3310     * So I have to use ARB for Gforce. (maybe if the sampler > 4 then use ARB?)
3311     *
3312     * http://developer.nvidia.com/object/General_FAQ.html#t6
3313     *
3314     * There are two new settings for GForce
3315     * the sampler one:
3316     * GL_MAX_TEXTURE_IMAGE_UNITS_ARB
3317     * and the texture one:
3318     * GL_MAX_TEXTURE_COORDS_ARB.
3319     * Ok GForce say it's ok to use glTexParameter/glGetTexParameter(...).
3320      ******************/
3321
3322     oldValue = This->stateBlock->samplerState[Sampler][Type];
3323     This->updateStateBlock->samplerState[Sampler][Type]         = Value;
3324     This->updateStateBlock->changed.samplerState[Sampler][Type] = Value;
3325
3326     /* Handle recording of state blocks */
3327     if (This->isRecordingState) {
3328         TRACE("Recording... not performing anything\n");
3329         return WINED3D_OK;
3330     }
3331
3332     if(oldValue == Value) {
3333         TRACE("Application is setting the old value over, nothing to do\n");
3334         return WINED3D_OK;
3335     }
3336
3337     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(Sampler));
3338
3339     return WINED3D_OK;
3340 }
3341
3342 static HRESULT WINAPI IWineD3DDeviceImpl_GetSamplerState(IWineD3DDevice *iface, DWORD Sampler, WINED3DSAMPLERSTATETYPE Type, DWORD* Value) {
3343     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3344
3345     TRACE("(%p) : Sampler %#x, Type %s (%#x)\n",
3346             This, Sampler, debug_d3dsamplerstate(Type), Type);
3347
3348     if (Sampler >= WINED3DVERTEXTEXTURESAMPLER0 && Sampler <= WINED3DVERTEXTEXTURESAMPLER3) {
3349         Sampler -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
3350     }
3351
3352     if (Sampler >= sizeof(This->stateBlock->samplerState)/sizeof(This->stateBlock->samplerState[0])) {
3353         ERR("Current Sampler overflows sampleState0 array (sampler %d)\n", Sampler);
3354         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
3355     }
3356     *Value = This->stateBlock->samplerState[Sampler][Type];
3357     TRACE("(%p) : Returning %#x\n", This, *Value);
3358
3359     return WINED3D_OK;
3360 }
3361
3362 static HRESULT WINAPI IWineD3DDeviceImpl_SetScissorRect(IWineD3DDevice *iface, CONST RECT* pRect) {
3363     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3364
3365     This->updateStateBlock->changed.scissorRect = TRUE;
3366     if(EqualRect(&This->updateStateBlock->scissorRect, pRect)) {
3367         TRACE("App is setting the old scissor rectangle over, nothing to do\n");
3368         return WINED3D_OK;
3369     }
3370     CopyRect(&This->updateStateBlock->scissorRect, pRect);
3371
3372     if(This->isRecordingState) {
3373         TRACE("Recording... not performing anything\n");
3374         return WINED3D_OK;
3375     }
3376
3377     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
3378
3379     return WINED3D_OK;
3380 }
3381
3382 static HRESULT WINAPI IWineD3DDeviceImpl_GetScissorRect(IWineD3DDevice *iface, RECT* pRect) {
3383     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3384
3385     *pRect = This->updateStateBlock->scissorRect;
3386     TRACE("(%p)Returning a Scissor Rect of %d:%d-%d:%d\n", This, pRect->left, pRect->top, pRect->right, pRect->bottom);
3387     return WINED3D_OK;
3388 }
3389
3390 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration* pDecl) {
3391     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
3392     IWineD3DVertexDeclaration *oldDecl = This->updateStateBlock->vertexDecl;
3393
3394     TRACE("(%p) : pDecl=%p\n", This, pDecl);
3395
3396     This->updateStateBlock->vertexDecl = pDecl;
3397     This->updateStateBlock->changed.vertexDecl = TRUE;
3398
3399     if (This->isRecordingState) {
3400         TRACE("Recording... not performing anything\n");
3401         return WINED3D_OK;
3402     } else if(pDecl == oldDecl) {
3403         /* Checked after the assignment to allow proper stateblock recording */
3404         TRACE("Application is setting the old declaration over, nothing to do\n");
3405         return WINED3D_OK;
3406     }
3407
3408     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
3409     return WINED3D_OK;
3410 }
3411
3412 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexDeclaration(IWineD3DDevice* iface, IWineD3DVertexDeclaration** ppDecl) {
3413     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3414
3415     TRACE("(%p) : ppDecl=%p\n", This, ppDecl);
3416
3417     *ppDecl = This->stateBlock->vertexDecl;
3418     if (NULL != *ppDecl) IWineD3DVertexDeclaration_AddRef(*ppDecl);
3419     return WINED3D_OK;
3420 }
3421
3422 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader* pShader) {
3423     IWineD3DDeviceImpl *This        = (IWineD3DDeviceImpl *)iface;
3424     IWineD3DVertexShader* oldShader = This->updateStateBlock->vertexShader;
3425
3426     This->updateStateBlock->vertexShader         = pShader;
3427     This->updateStateBlock->changed.vertexShader = TRUE;
3428
3429     if (This->isRecordingState) {
3430         if(pShader) IWineD3DVertexShader_AddRef(pShader);
3431         if(oldShader) IWineD3DVertexShader_Release(oldShader);
3432         TRACE("Recording... not performing anything\n");
3433         return WINED3D_OK;
3434     } else if(oldShader == pShader) {
3435         /* Checked here to allow proper stateblock recording */
3436         TRACE("App is setting the old shader over, nothing to do\n");
3437         return WINED3D_OK;
3438     }
3439
3440     TRACE("(%p) : setting pShader(%p)\n", This, pShader);
3441     if(pShader) IWineD3DVertexShader_AddRef(pShader);
3442     if(oldShader) IWineD3DVertexShader_Release(oldShader);
3443
3444     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VSHADER);
3445
3446     return WINED3D_OK;
3447 }
3448
3449 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShader(IWineD3DDevice *iface, IWineD3DVertexShader** ppShader) {
3450     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3451
3452     if (NULL == ppShader) {
3453         return WINED3DERR_INVALIDCALL;
3454     }
3455     *ppShader = This->stateBlock->vertexShader;
3456     if( NULL != *ppShader)
3457         IWineD3DVertexShader_AddRef(*ppShader);
3458
3459     TRACE("(%p) : returning %p\n", This, *ppShader);
3460     return WINED3D_OK;
3461 }
3462
3463 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantB(
3464     IWineD3DDevice *iface,
3465     UINT start,
3466     CONST BOOL *srcData,
3467     UINT count) {
3468
3469     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3470     int i, cnt = min(count, MAX_CONST_B - start);
3471
3472     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3473             iface, srcData, start, count);
3474
3475     if (srcData == NULL || cnt < 0)
3476         return WINED3DERR_INVALIDCALL;
3477
3478     memcpy(&This->updateStateBlock->vertexShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3479     for (i = 0; i < cnt; i++)
3480         TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3481
3482     for (i = start; i < cnt + start; ++i) {
3483         This->updateStateBlock->changed.vertexShaderConstantsB |= (1 << i);
3484     }
3485
3486     if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3487
3488     return WINED3D_OK;
3489 }
3490
3491 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantB(
3492     IWineD3DDevice *iface,
3493     UINT start,
3494     BOOL *dstData,
3495     UINT count) {
3496
3497     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3498     int cnt = min(count, MAX_CONST_B - start);
3499
3500     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3501             iface, dstData, start, count);
3502
3503     if (dstData == NULL || cnt < 0)
3504         return WINED3DERR_INVALIDCALL;
3505
3506     memcpy(dstData, &This->stateBlock->vertexShaderConstantB[start], cnt * sizeof(BOOL));
3507     return WINED3D_OK;
3508 }
3509
3510 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantI(
3511     IWineD3DDevice *iface,
3512     UINT start,
3513     CONST int *srcData,
3514     UINT count) {
3515
3516     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3517     int i, cnt = min(count, MAX_CONST_I - start);
3518
3519     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3520             iface, srcData, start, count);
3521
3522     if (srcData == NULL || cnt < 0)
3523         return WINED3DERR_INVALIDCALL;
3524
3525     memcpy(&This->updateStateBlock->vertexShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3526     for (i = 0; i < cnt; i++)
3527         TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3528            srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3529
3530     for (i = start; i < cnt + start; ++i) {
3531         This->updateStateBlock->changed.vertexShaderConstantsI |= (1 << i);
3532     }
3533
3534     if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3535
3536     return WINED3D_OK;
3537 }
3538
3539 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantI(
3540     IWineD3DDevice *iface,
3541     UINT start,
3542     int *dstData,
3543     UINT count) {
3544
3545     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3546     int cnt = min(count, MAX_CONST_I - start);
3547
3548     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3549             iface, dstData, start, count);
3550
3551     if (dstData == NULL || ((signed int) MAX_CONST_I - (signed int) start) <= (signed int) 0)
3552         return WINED3DERR_INVALIDCALL;
3553
3554     memcpy(dstData, &This->stateBlock->vertexShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3555     return WINED3D_OK;
3556 }
3557
3558 static HRESULT WINAPI IWineD3DDeviceImpl_SetVertexShaderConstantF(
3559     IWineD3DDevice *iface,
3560     UINT start,
3561     CONST float *srcData,
3562     UINT count) {
3563
3564     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3565     UINT i;
3566
3567     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3568             iface, srcData, start, count);
3569
3570     /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3571     if (srcData == NULL || start + count > GL_LIMITS(vshader_constantsF) || start > GL_LIMITS(vshader_constantsF))
3572         return WINED3DERR_INVALIDCALL;
3573
3574     memcpy(&This->updateStateBlock->vertexShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3575     if(TRACE_ON(d3d)) {
3576         for (i = 0; i < count; i++)
3577             TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3578                 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3579     }
3580
3581     if (!This->isRecordingState)
3582     {
3583         This->shader_backend->shader_update_float_vertex_constants(iface, start, count);
3584         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VERTEXSHADERCONSTANT);
3585     }
3586
3587     memset(This->updateStateBlock->changed.vertexShaderConstantsF + start, 1,
3588             sizeof(*This->updateStateBlock->changed.vertexShaderConstantsF) * count);
3589
3590     return WINED3D_OK;
3591 }
3592
3593 static HRESULT WINAPI IWineD3DDeviceImpl_GetVertexShaderConstantF(
3594     IWineD3DDevice *iface,
3595     UINT start,
3596     float *dstData,
3597     UINT count) {
3598
3599     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3600     int cnt = min(count, GL_LIMITS(vshader_constantsF) - start);
3601
3602     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3603             iface, dstData, start, count);
3604
3605     if (dstData == NULL || cnt < 0)
3606         return WINED3DERR_INVALIDCALL;
3607
3608     memcpy(dstData, &This->stateBlock->vertexShaderConstantF[start * 4], cnt * sizeof(float) * 4);
3609     return WINED3D_OK;
3610 }
3611
3612 static inline void markTextureStagesDirty(IWineD3DDeviceImpl *This, DWORD stage) {
3613     DWORD i;
3614     for(i = 0; i < WINED3D_HIGHEST_TEXTURE_STATE; i++) {
3615         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(stage, i));
3616     }
3617 }
3618
3619 static void device_map_stage(IWineD3DDeviceImpl *This, int stage, int unit) {
3620     int i = This->rev_tex_unit_map[unit];
3621     int j = This->texUnitMap[stage];
3622
3623     This->texUnitMap[stage] = unit;
3624     if (i != -1 && i != stage) {
3625         This->texUnitMap[i] = -1;
3626     }
3627
3628     This->rev_tex_unit_map[unit] = stage;
3629     if (j != -1 && j != unit) {
3630         This->rev_tex_unit_map[j] = -1;
3631     }
3632 }
3633
3634 static void device_update_fixed_function_usage_map(IWineD3DDeviceImpl *This) {
3635     int i;
3636
3637     for (i = 0; i < MAX_TEXTURES; ++i) {
3638         WINED3DTEXTUREOP color_op = This->stateBlock->textureState[i][WINED3DTSS_COLOROP];
3639         WINED3DTEXTUREOP alpha_op = This->stateBlock->textureState[i][WINED3DTSS_ALPHAOP];
3640         DWORD color_arg1 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG1] & WINED3DTA_SELECTMASK;
3641         DWORD color_arg2 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG2] & WINED3DTA_SELECTMASK;
3642         DWORD color_arg3 = This->stateBlock->textureState[i][WINED3DTSS_COLORARG0] & WINED3DTA_SELECTMASK;
3643         DWORD alpha_arg1 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG1] & WINED3DTA_SELECTMASK;
3644         DWORD alpha_arg2 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG2] & WINED3DTA_SELECTMASK;
3645         DWORD alpha_arg3 = This->stateBlock->textureState[i][WINED3DTSS_ALPHAARG0] & WINED3DTA_SELECTMASK;
3646
3647         if (color_op == WINED3DTOP_DISABLE) {
3648             /* Not used, and disable higher stages */
3649             while (i < MAX_TEXTURES) {
3650                 This->fixed_function_usage_map[i] = FALSE;
3651                 ++i;
3652             }
3653             break;
3654         }
3655
3656         if (((color_arg1 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG2)
3657                 || ((color_arg2 == WINED3DTA_TEXTURE) && color_op != WINED3DTOP_SELECTARG1)
3658                 || ((color_arg3 == WINED3DTA_TEXTURE) && (color_op == WINED3DTOP_MULTIPLYADD || color_op == WINED3DTOP_LERP))
3659                 || ((alpha_arg1 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG2)
3660                 || ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3DTOP_SELECTARG1)
3661                 || ((alpha_arg3 == WINED3DTA_TEXTURE) && (alpha_op == WINED3DTOP_MULTIPLYADD || alpha_op == WINED3DTOP_LERP))) {
3662             This->fixed_function_usage_map[i] = TRUE;
3663         } else {
3664             This->fixed_function_usage_map[i] = FALSE;
3665         }
3666
3667         if ((color_op == WINED3DTOP_BUMPENVMAP || color_op == WINED3DTOP_BUMPENVMAPLUMINANCE) && i < MAX_TEXTURES - 1) {
3668             This->fixed_function_usage_map[i+1] = TRUE;
3669         }
3670     }
3671 }
3672
3673 static void device_map_fixed_function_samplers(IWineD3DDeviceImpl *This) {
3674     int i, tex;
3675
3676     device_update_fixed_function_usage_map(This);
3677
3678     if (This->max_ffp_textures == This->max_ffp_texture_stages ||
3679         This->stateBlock->lowest_disabled_stage <= This->max_ffp_textures) {
3680         for (i = 0; i < This->stateBlock->lowest_disabled_stage; ++i) {
3681             if (!This->fixed_function_usage_map[i]) continue;
3682
3683             if (This->texUnitMap[i] != i) {
3684                 device_map_stage(This, i, i);
3685                 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3686                 markTextureStagesDirty(This, i);
3687             }
3688         }
3689         return;
3690     }
3691
3692     /* Now work out the mapping */
3693     tex = 0;
3694     for (i = 0; i < This->stateBlock->lowest_disabled_stage; ++i) {
3695         if (!This->fixed_function_usage_map[i]) continue;
3696
3697         if (This->texUnitMap[i] != tex) {
3698             device_map_stage(This, i, tex);
3699             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3700             markTextureStagesDirty(This, i);
3701         }
3702
3703         ++tex;
3704     }
3705 }
3706
3707 static void device_map_psamplers(IWineD3DDeviceImpl *This) {
3708     const DWORD *sampler_tokens =
3709             ((IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader)->baseShader.reg_maps.samplers;
3710     int i;
3711
3712     for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
3713         if (sampler_tokens[i] && This->texUnitMap[i] != i) {
3714             device_map_stage(This, i, i);
3715             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(i));
3716             if (i < MAX_TEXTURES) {
3717                 markTextureStagesDirty(This, i);
3718             }
3719         }
3720     }
3721 }
3722
3723 static BOOL device_unit_free_for_vs(IWineD3DDeviceImpl *This, const DWORD *pshader_sampler_tokens,
3724         const DWORD *vshader_sampler_tokens, int unit)
3725 {
3726     int current_mapping = This->rev_tex_unit_map[unit];
3727
3728     if (current_mapping == -1) {
3729         /* Not currently used */
3730         return TRUE;
3731     }
3732
3733     if (current_mapping < MAX_FRAGMENT_SAMPLERS) {
3734         /* Used by a fragment sampler */
3735
3736         if (!pshader_sampler_tokens) {
3737             /* No pixel shader, check fixed function */
3738             return current_mapping >= MAX_TEXTURES || !This->fixed_function_usage_map[current_mapping];
3739         }
3740
3741         /* Pixel shader, check the shader's sampler map */
3742         return !pshader_sampler_tokens[current_mapping];
3743     }
3744
3745     /* Used by a vertex sampler */
3746     return !vshader_sampler_tokens[current_mapping];
3747 }
3748
3749 static void device_map_vsamplers(IWineD3DDeviceImpl *This, BOOL ps) {
3750     const DWORD *vshader_sampler_tokens =
3751             ((IWineD3DVertexShaderImpl *)This->stateBlock->vertexShader)->baseShader.reg_maps.samplers;
3752     const DWORD *pshader_sampler_tokens = NULL;
3753     int start = GL_LIMITS(combined_samplers) - 1;
3754     int i;
3755
3756     if (ps) {
3757         IWineD3DPixelShaderImpl *pshader = (IWineD3DPixelShaderImpl *)This->stateBlock->pixelShader;
3758
3759         /* Note that we only care if a sampler is sampled or not, not the sampler's specific type.
3760          * Otherwise we'd need to call shader_update_samplers() here for 1.x pixelshaders. */
3761         pshader_sampler_tokens = pshader->baseShader.reg_maps.samplers;
3762     }
3763
3764     for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
3765         int vsampler_idx = i + MAX_FRAGMENT_SAMPLERS;
3766         if (vshader_sampler_tokens[i]) {
3767             if (This->texUnitMap[vsampler_idx] != -1) {
3768                 /* Already mapped somewhere */
3769                 continue;
3770             }
3771
3772             while (start >= 0) {
3773                 if (device_unit_free_for_vs(This, pshader_sampler_tokens, vshader_sampler_tokens, start)) {
3774                     device_map_stage(This, vsampler_idx, start);
3775                     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(vsampler_idx));
3776
3777                     --start;
3778                     break;
3779                 }
3780
3781                 --start;
3782             }
3783         }
3784     }
3785 }
3786
3787 void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This) {
3788     BOOL vs = use_vs(This);
3789     BOOL ps = use_ps(This);
3790     /*
3791      * Rules are:
3792      * -> Pixel shaders need a 1:1 map. In theory the shader input could be mapped too, but
3793      * that would be really messy and require shader recompilation
3794      * -> When the mapping of a stage is changed, sampler and ALL texture stage states have
3795      * to be reset. Because of that try to work with a 1:1 mapping as much as possible
3796      */
3797     if (ps) {
3798         device_map_psamplers(This);
3799     } else {
3800         device_map_fixed_function_samplers(This);
3801     }
3802
3803     if (vs) {
3804         device_map_vsamplers(This, ps);
3805     }
3806 }
3807
3808 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader *pShader) {
3809     IWineD3DDeviceImpl *This        = (IWineD3DDeviceImpl *)iface;
3810     IWineD3DPixelShader *oldShader  = This->updateStateBlock->pixelShader;
3811     This->updateStateBlock->pixelShader         = pShader;
3812     This->updateStateBlock->changed.pixelShader = TRUE;
3813
3814     /* Handle recording of state blocks */
3815     if (This->isRecordingState) {
3816         TRACE("Recording... not performing anything\n");
3817     }
3818
3819     if (This->isRecordingState) {
3820         TRACE("Recording... not performing anything\n");
3821         if(pShader) IWineD3DPixelShader_AddRef(pShader);
3822         if(oldShader) IWineD3DPixelShader_Release(oldShader);
3823         return WINED3D_OK;
3824     }
3825
3826     if(pShader == oldShader) {
3827         TRACE("App is setting the old pixel shader over, nothing to do\n");
3828         return WINED3D_OK;
3829     }
3830
3831     if(pShader) IWineD3DPixelShader_AddRef(pShader);
3832     if(oldShader) IWineD3DPixelShader_Release(oldShader);
3833
3834     TRACE("(%p) : setting pShader(%p)\n", This, pShader);
3835     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADER);
3836
3837     return WINED3D_OK;
3838 }
3839
3840 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShader(IWineD3DDevice *iface, IWineD3DPixelShader **ppShader) {
3841     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3842
3843     if (NULL == ppShader) {
3844         WARN("(%p) : PShader is NULL, returning INVALIDCALL\n", This);
3845         return WINED3DERR_INVALIDCALL;
3846     }
3847
3848     *ppShader =  This->stateBlock->pixelShader;
3849     if (NULL != *ppShader) {
3850         IWineD3DPixelShader_AddRef(*ppShader);
3851     }
3852     TRACE("(%p) : returning %p\n", This, *ppShader);
3853     return WINED3D_OK;
3854 }
3855
3856 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantB(
3857     IWineD3DDevice *iface,
3858     UINT start,
3859     CONST BOOL *srcData,
3860     UINT count) {
3861
3862     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3863     int i, cnt = min(count, MAX_CONST_B - start);
3864
3865     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3866             iface, srcData, start, count);
3867
3868     if (srcData == NULL || cnt < 0)
3869         return WINED3DERR_INVALIDCALL;
3870
3871     memcpy(&This->updateStateBlock->pixelShaderConstantB[start], srcData, cnt * sizeof(BOOL));
3872     for (i = 0; i < cnt; i++)
3873         TRACE("Set BOOL constant %u to %s\n", start + i, srcData[i]? "true":"false");
3874
3875     for (i = start; i < cnt + start; ++i) {
3876         This->updateStateBlock->changed.pixelShaderConstantsB |= (1 << i);
3877     }
3878
3879     if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3880
3881     return WINED3D_OK;
3882 }
3883
3884 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantB(
3885     IWineD3DDevice *iface,
3886     UINT start,
3887     BOOL *dstData,
3888     UINT count) {
3889
3890     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3891     int cnt = min(count, MAX_CONST_B - start);
3892
3893     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3894             iface, dstData, start, count);
3895
3896     if (dstData == NULL || cnt < 0)
3897         return WINED3DERR_INVALIDCALL;
3898
3899     memcpy(dstData, &This->stateBlock->pixelShaderConstantB[start], cnt * sizeof(BOOL));
3900     return WINED3D_OK;
3901 }
3902
3903 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantI(
3904     IWineD3DDevice *iface,
3905     UINT start,
3906     CONST int *srcData,
3907     UINT count) {
3908
3909     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3910     int i, cnt = min(count, MAX_CONST_I - start);
3911
3912     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3913             iface, srcData, start, count);
3914
3915     if (srcData == NULL || cnt < 0)
3916         return WINED3DERR_INVALIDCALL;
3917
3918     memcpy(&This->updateStateBlock->pixelShaderConstantI[start * 4], srcData, cnt * sizeof(int) * 4);
3919     for (i = 0; i < cnt; i++)
3920         TRACE("Set INT constant %u to { %d, %d, %d, %d }\n", start + i,
3921            srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3922
3923     for (i = start; i < cnt + start; ++i) {
3924         This->updateStateBlock->changed.pixelShaderConstantsI |= (1 << i);
3925     }
3926
3927     if (!This->isRecordingState) IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3928
3929     return WINED3D_OK;
3930 }
3931
3932 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantI(
3933     IWineD3DDevice *iface,
3934     UINT start,
3935     int *dstData,
3936     UINT count) {
3937
3938     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3939     int cnt = min(count, MAX_CONST_I - start);
3940
3941     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3942             iface, dstData, start, count);
3943
3944     if (dstData == NULL || cnt < 0)
3945         return WINED3DERR_INVALIDCALL;
3946
3947     memcpy(dstData, &This->stateBlock->pixelShaderConstantI[start * 4], cnt * sizeof(int) * 4);
3948     return WINED3D_OK;
3949 }
3950
3951 static HRESULT WINAPI IWineD3DDeviceImpl_SetPixelShaderConstantF(
3952     IWineD3DDevice *iface,
3953     UINT start,
3954     CONST float *srcData,
3955     UINT count) {
3956
3957     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3958     UINT i;
3959
3960     TRACE("(iface %p, srcData %p, start %d, count %d)\n",
3961             iface, srcData, start, count);
3962
3963     /* Specifically test start > limit to catch MAX_UINT overflows when adding start + count */
3964     if (srcData == NULL || start + count > GL_LIMITS(pshader_constantsF) || start > GL_LIMITS(pshader_constantsF))
3965         return WINED3DERR_INVALIDCALL;
3966
3967     memcpy(&This->updateStateBlock->pixelShaderConstantF[start * 4], srcData, count * sizeof(float) * 4);
3968     if(TRACE_ON(d3d)) {
3969         for (i = 0; i < count; i++)
3970             TRACE("Set FLOAT constant %u to { %f, %f, %f, %f }\n", start + i,
3971                 srcData[i*4], srcData[i*4+1], srcData[i*4+2], srcData[i*4+3]);
3972     }
3973
3974     if (!This->isRecordingState)
3975     {
3976         This->shader_backend->shader_update_float_pixel_constants(iface, start, count);
3977         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_PIXELSHADERCONSTANT);
3978     }
3979
3980     memset(This->updateStateBlock->changed.pixelShaderConstantsF + start, 1,
3981             sizeof(*This->updateStateBlock->changed.pixelShaderConstantsF) * count);
3982
3983     return WINED3D_OK;
3984 }
3985
3986 static HRESULT WINAPI IWineD3DDeviceImpl_GetPixelShaderConstantF(
3987     IWineD3DDevice *iface,
3988     UINT start,
3989     float *dstData,
3990     UINT count) {
3991
3992     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3993     int cnt = min(count, GL_LIMITS(pshader_constantsF) - start);
3994
3995     TRACE("(iface %p, dstData %p, start %d, count %d)\n",
3996             iface, dstData, start, count);
3997
3998     if (dstData == NULL || cnt < 0)
3999         return WINED3DERR_INVALIDCALL;
4000
4001     memcpy(dstData, &This->stateBlock->pixelShaderConstantF[start * 4], cnt * sizeof(float) * 4);
4002     return WINED3D_OK;
4003 }
4004
4005 #define copy_and_next(dest, src, size) memcpy(dest, src, size); dest += (size)
4006 static HRESULT process_vertices_strided(IWineD3DDeviceImpl *This, DWORD dwDestIndex, DWORD dwCount,
4007         const WineDirect3DVertexStridedData *lpStrideData, IWineD3DVertexBufferImpl *dest, DWORD dwFlags)
4008 {
4009     char *dest_ptr, *dest_conv = NULL, *dest_conv_addr = NULL;
4010     unsigned int i;
4011     DWORD DestFVF = dest->fvf;
4012     WINED3DVIEWPORT vp;
4013     WINED3DMATRIX mat, proj_mat, view_mat, world_mat;
4014     BOOL doClip;
4015     DWORD numTextures;
4016
4017     if (lpStrideData->u.s.normal.lpData) {
4018         WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
4019     }
4020
4021     if (lpStrideData->u.s.position.lpData == NULL) {
4022         ERR("Source has no position mask\n");
4023         return WINED3DERR_INVALIDCALL;
4024     }
4025
4026     /* We might access VBOs from this code, so hold the lock */
4027     ENTER_GL();
4028
4029     if (dest->resource.allocatedMemory == NULL) {
4030         /* This may happen if we do direct locking into a vbo. Unlikely,
4031          * but theoretically possible(ddraw processvertices test)
4032          */
4033         dest->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), 0, dest->resource.size);
4034         if(!dest->resource.allocatedMemory) {
4035             LEAVE_GL();
4036             ERR("Out of memory\n");
4037             return E_OUTOFMEMORY;
4038         }
4039         if(dest->vbo) {
4040             const void *src;
4041             GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->vbo));
4042             checkGLcall("glBindBufferARB");
4043             src = GL_EXTCALL(glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_ONLY_ARB));
4044             if(src) {
4045                 memcpy(dest->resource.allocatedMemory, src, dest->resource.size);
4046             }
4047             GL_EXTCALL(glUnmapBufferARB(GL_ARRAY_BUFFER_ARB));
4048             checkGLcall("glUnmapBufferARB");
4049         }
4050     }
4051
4052     /* Get a pointer into the destination vbo(create one if none exists) and
4053      * write correct opengl data into it. It's cheap and allows us to run drawStridedFast
4054      */
4055     if(!dest->vbo && GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
4056         dest->Flags |= VBFLAG_CREATEVBO;
4057         IWineD3DVertexBuffer_PreLoad((IWineD3DVertexBuffer *) dest);
4058     }
4059
4060     if(dest->vbo) {
4061         unsigned char extrabytes = 0;
4062         /* If the destination vertex buffer has D3DFVF_XYZ position(non-rhw), native d3d writes RHW position, where the RHW
4063          * gets written into the 4 bytes after the Z position. In the case of a dest buffer that only has D3DFVF_XYZ data,
4064          * this may write 4 extra bytes beyond the area that should be written
4065          */
4066         if(DestFVF == WINED3DFVF_XYZ) extrabytes = 4;
4067         dest_conv_addr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwCount * get_flexible_vertex_size(DestFVF) + extrabytes);
4068         if(!dest_conv_addr) {
4069             ERR("Out of memory\n");
4070             /* Continue without storing converted vertices */
4071         }
4072         dest_conv = dest_conv_addr;
4073     }
4074
4075     /* Should I clip?
4076      * a) WINED3DRS_CLIPPING is enabled
4077      * b) WINED3DVOP_CLIP is passed
4078      */
4079     if(This->stateBlock->renderState[WINED3DRS_CLIPPING]) {
4080         static BOOL warned = FALSE;
4081         /*
4082          * The clipping code is not quite correct. Some things need
4083          * to be checked against IDirect3DDevice3 (!), d3d8 and d3d9,
4084          * so disable clipping for now.
4085          * (The graphics in Half-Life are broken, and my processvertices
4086          *  test crashes with IDirect3DDevice3)
4087         doClip = TRUE;
4088          */
4089         doClip = FALSE;
4090         if(!warned) {
4091            warned = TRUE;
4092            FIXME("Clipping is broken and disabled for now\n");
4093         }
4094     } else doClip = FALSE;
4095     dest_ptr = ((char *) dest->resource.allocatedMemory) + dwDestIndex * get_flexible_vertex_size(DestFVF);
4096
4097     IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4098                                  WINED3DTS_VIEW,
4099                                  &view_mat);
4100     IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4101                                  WINED3DTS_PROJECTION,
4102                                  &proj_mat);
4103     IWineD3DDevice_GetTransform( (IWineD3DDevice *) This,
4104                                  WINED3DTS_WORLDMATRIX(0),
4105                                  &world_mat);
4106
4107     TRACE("View mat:\n");
4108     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);
4109     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);
4110     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);
4111     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);
4112
4113     TRACE("Proj mat:\n");
4114     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);
4115     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);
4116     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);
4117     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);
4118
4119     TRACE("World mat:\n");
4120     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);
4121     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);
4122     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);
4123     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);
4124
4125     /* Get the viewport */
4126     IWineD3DDevice_GetViewport( (IWineD3DDevice *) This, &vp);
4127     TRACE("Viewport: X=%d, Y=%d, Width=%d, Height=%d, MinZ=%f, MaxZ=%f\n",
4128           vp.X, vp.Y, vp.Width, vp.Height, vp.MinZ, vp.MaxZ);
4129
4130     multiply_matrix(&mat,&view_mat,&world_mat);
4131     multiply_matrix(&mat,&proj_mat,&mat);
4132
4133     numTextures = (DestFVF & WINED3DFVF_TEXCOUNT_MASK) >> WINED3DFVF_TEXCOUNT_SHIFT;
4134
4135     for (i = 0; i < dwCount; i+= 1) {
4136         unsigned int tex_index;
4137
4138         if ( ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZ ) ||
4139              ((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW ) ) {
4140             /* The position first */
4141             const float *p =
4142                     (const float *)(lpStrideData->u.s.position.lpData + i * lpStrideData->u.s.position.dwStride);
4143             float x, y, z, rhw;
4144             TRACE("In: ( %06.2f %06.2f %06.2f )\n", p[0], p[1], p[2]);
4145
4146             /* Multiplication with world, view and projection matrix */
4147             x =   (p[0] * mat.u.s._11) + (p[1] * mat.u.s._21) + (p[2] * mat.u.s._31) + (1.0 * mat.u.s._41);
4148             y =   (p[0] * mat.u.s._12) + (p[1] * mat.u.s._22) + (p[2] * mat.u.s._32) + (1.0 * mat.u.s._42);
4149             z =   (p[0] * mat.u.s._13) + (p[1] * mat.u.s._23) + (p[2] * mat.u.s._33) + (1.0 * mat.u.s._43);
4150             rhw = (p[0] * mat.u.s._14) + (p[1] * mat.u.s._24) + (p[2] * mat.u.s._34) + (1.0 * mat.u.s._44);
4151
4152             TRACE("x=%f y=%f z=%f rhw=%f\n", x, y, z, rhw);
4153
4154             /* WARNING: The following things are taken from d3d7 and were not yet checked
4155              * against d3d8 or d3d9!
4156              */
4157
4158             /* Clipping conditions: From msdn
4159              *
4160              * A vertex is clipped if it does not match the following requirements
4161              * -rhw < x <= rhw
4162              * -rhw < y <= rhw
4163              *    0 < z <= rhw
4164              *    0 < rhw ( Not in d3d7, but tested in d3d7)
4165              *
4166              * If clipping is on is determined by the D3DVOP_CLIP flag in D3D7, and
4167              * by the D3DRS_CLIPPING in D3D9(according to the msdn, not checked)
4168              *
4169              */
4170
4171             if( !doClip ||
4172                 ( (-rhw -eps < x) && (-rhw -eps < y) && ( -eps < z) &&
4173                   (x <= rhw + eps) && (y <= rhw + eps ) && (z <= rhw + eps) &&
4174                   ( rhw > eps ) ) ) {
4175
4176                 /* "Normal" viewport transformation (not clipped)
4177                  * 1) The values are divided by rhw
4178                  * 2) The y axis is negative, so multiply it with -1
4179                  * 3) Screen coordinates go from -(Width/2) to +(Width/2) and
4180                  *    -(Height/2) to +(Height/2). The z range is MinZ to MaxZ
4181                  * 4) Multiply x with Width/2 and add Width/2
4182                  * 5) The same for the height
4183                  * 6) Add the viewpoint X and Y to the 2D coordinates and
4184                  *    The minimum Z value to z
4185                  * 7) rhw = 1 / rhw Reciprocal of Homogeneous W....
4186                  *
4187                  * Well, basically it's simply a linear transformation into viewport
4188                  * coordinates
4189                  */
4190
4191                 x /= rhw;
4192                 y /= rhw;
4193                 z /= rhw;
4194
4195                 y *= -1;
4196
4197                 x *= vp.Width / 2;
4198                 y *= vp.Height / 2;
4199                 z *= vp.MaxZ - vp.MinZ;
4200
4201                 x += vp.Width / 2 + vp.X;
4202                 y += vp.Height / 2 + vp.Y;
4203                 z += vp.MinZ;
4204
4205                 rhw = 1 / rhw;
4206             } else {
4207                 /* That vertex got clipped
4208                  * Contrary to OpenGL it is not dropped completely, it just
4209                  * undergoes a different calculation.
4210                  */
4211                 TRACE("Vertex got clipped\n");
4212                 x += rhw;
4213                 y += rhw;
4214
4215                 x  /= 2;
4216                 y  /= 2;
4217
4218                 /* Msdn mentions that Direct3D9 keeps a list of clipped vertices
4219                  * outside of the main vertex buffer memory. That needs some more
4220                  * investigation...
4221                  */
4222             }
4223
4224             TRACE("Writing (%f %f %f) %f\n", x, y, z, rhw);
4225
4226
4227             ( (float *) dest_ptr)[0] = x;
4228             ( (float *) dest_ptr)[1] = y;
4229             ( (float *) dest_ptr)[2] = z;
4230             ( (float *) dest_ptr)[3] = rhw; /* SIC, see ddraw test! */
4231
4232             dest_ptr += 3 * sizeof(float);
4233
4234             if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
4235                 dest_ptr += sizeof(float);
4236             }
4237
4238             if(dest_conv) {
4239                 float w = 1 / rhw;
4240                 ( (float *) dest_conv)[0] = x * w;
4241                 ( (float *) dest_conv)[1] = y * w;
4242                 ( (float *) dest_conv)[2] = z * w;
4243                 ( (float *) dest_conv)[3] = w;
4244
4245                 dest_conv += 3 * sizeof(float);
4246
4247                 if((DestFVF & WINED3DFVF_POSITION_MASK) == WINED3DFVF_XYZRHW) {
4248                     dest_conv += sizeof(float);
4249                 }
4250             }
4251         }
4252         if (DestFVF & WINED3DFVF_PSIZE) {
4253             dest_ptr += sizeof(DWORD);
4254             if(dest_conv) dest_conv += sizeof(DWORD);
4255         }
4256         if (DestFVF & WINED3DFVF_NORMAL) {
4257             const float *normal =
4258                     (const float *)(lpStrideData->u.s.normal.lpData + i * lpStrideData->u.s.normal.dwStride);
4259             /* AFAIK this should go into the lighting information */
4260             FIXME("Didn't expect the destination to have a normal\n");
4261             copy_and_next(dest_ptr, normal, 3 * sizeof(float));
4262             if(dest_conv) {
4263                 copy_and_next(dest_conv, normal, 3 * sizeof(float));
4264             }
4265         }
4266
4267         if (DestFVF & WINED3DFVF_DIFFUSE) {
4268             const DWORD *color_d =
4269                     (const DWORD *)(lpStrideData->u.s.diffuse.lpData + i * lpStrideData->u.s.diffuse.dwStride);
4270             if(!color_d) {
4271                 static BOOL warned = FALSE;
4272
4273                 if(!warned) {
4274                     ERR("No diffuse color in source, but destination has one\n");
4275                     warned = TRUE;
4276                 }
4277
4278                 *( (DWORD *) dest_ptr) = 0xffffffff;
4279                 dest_ptr += sizeof(DWORD);
4280
4281                 if(dest_conv) {
4282                     *( (DWORD *) dest_conv) = 0xffffffff;
4283                     dest_conv += sizeof(DWORD);
4284                 }
4285             }
4286             else {
4287                 copy_and_next(dest_ptr, color_d, sizeof(DWORD));
4288                 if(dest_conv) {
4289                     *( (DWORD *) dest_conv)  = (*color_d & 0xff00ff00)      ; /* Alpha + green */
4290                     *( (DWORD *) dest_conv) |= (*color_d & 0x00ff0000) >> 16; /* Red */
4291                     *( (DWORD *) dest_conv) |= (*color_d & 0xff0000ff) << 16; /* Blue */
4292                     dest_conv += sizeof(DWORD);
4293                 }
4294             }
4295         }
4296
4297         if (DestFVF & WINED3DFVF_SPECULAR) {
4298             /* What's the color value in the feedback buffer? */
4299             const DWORD *color_s =
4300                     (const DWORD *)(lpStrideData->u.s.specular.lpData + i * lpStrideData->u.s.specular.dwStride);
4301             if(!color_s) {
4302                 static BOOL warned = FALSE;
4303
4304                 if(!warned) {
4305                     ERR("No specular color in source, but destination has one\n");
4306                     warned = TRUE;
4307                 }
4308
4309                 *( (DWORD *) dest_ptr) = 0xFF000000;
4310                 dest_ptr += sizeof(DWORD);
4311
4312                 if(dest_conv) {
4313                     *( (DWORD *) dest_conv) = 0xFF000000;
4314                     dest_conv += sizeof(DWORD);
4315                 }
4316             }
4317             else {
4318                 copy_and_next(dest_ptr, color_s, sizeof(DWORD));
4319                 if(dest_conv) {
4320                     *( (DWORD *) dest_conv)  = (*color_s & 0xff00ff00)      ; /* Alpha + green */
4321                     *( (DWORD *) dest_conv) |= (*color_s & 0x00ff0000) >> 16; /* Red */
4322                     *( (DWORD *) dest_conv) |= (*color_s & 0xff0000ff) << 16; /* Blue */
4323                     dest_conv += sizeof(DWORD);
4324                 }
4325             }
4326         }
4327
4328         for (tex_index = 0; tex_index < numTextures; tex_index++) {
4329             const float *tex_coord =
4330                     (const float *)(lpStrideData->u.s.texCoords[tex_index].lpData +
4331                             i * lpStrideData->u.s.texCoords[tex_index].dwStride);
4332             if(!tex_coord) {
4333                 ERR("No source texture, but destination requests one\n");
4334                 dest_ptr+=GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
4335                 if(dest_conv) dest_conv += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
4336             }
4337             else {
4338                 copy_and_next(dest_ptr, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
4339                 if(dest_conv) {
4340                     copy_and_next(dest_conv, tex_coord, GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float));
4341                 }
4342             }
4343         }
4344     }
4345
4346     if(dest_conv) {
4347         GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, dest->vbo));
4348         checkGLcall("glBindBufferARB(GL_ARRAY_BUFFER_ARB)");
4349         GL_EXTCALL(glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, dwDestIndex * get_flexible_vertex_size(DestFVF),
4350                                       dwCount * get_flexible_vertex_size(DestFVF),
4351                                       dest_conv_addr));
4352         checkGLcall("glBufferSubDataARB(GL_ARRAY_BUFFER_ARB)");
4353         HeapFree(GetProcessHeap(), 0, dest_conv_addr);
4354     }
4355
4356     LEAVE_GL();
4357
4358     return WINED3D_OK;
4359 }
4360 #undef copy_and_next
4361
4362 static HRESULT WINAPI IWineD3DDeviceImpl_ProcessVertices(IWineD3DDevice *iface, UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IWineD3DVertexBuffer* pDestBuffer, IWineD3DVertexDeclaration* pVertexDecl, DWORD Flags) {
4363     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4364     WineDirect3DVertexStridedData strided;
4365     BOOL vbo = FALSE, streamWasUP = This->stateBlock->streamIsUP;
4366     TRACE("(%p)->(%d,%d,%d,%p,%p,%d\n", This, SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags);
4367
4368     if(pVertexDecl) {
4369         ERR("Output vertex declaration not implemented yet\n");
4370     }
4371
4372     /* Need any context to write to the vbo. */
4373     ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4374
4375     /* ProcessVertices reads from vertex buffers, which have to be assigned. DrawPrimitive and DrawPrimitiveUP
4376      * control the streamIsUP flag, thus restore it afterwards.
4377      */
4378     This->stateBlock->streamIsUP = FALSE;
4379     memset(&strided, 0, sizeof(strided));
4380     primitiveDeclarationConvertToStridedData(iface, FALSE, &strided, &vbo);
4381     This->stateBlock->streamIsUP = streamWasUP;
4382
4383     if(vbo || SrcStartIndex) {
4384         unsigned int i;
4385         /* ProcessVertices can't convert FROM a vbo, and vertex buffers used to source into ProcessVertices are
4386          * unlikely to ever be used for drawing. Release vbos in those buffers and fix up the strided structure
4387          *
4388          * Also get the start index in, but only loop over all elements if there's something to add at all.
4389          */
4390 #define FIXSRC(type) \
4391         if(strided.u.s.type.VBO) { \
4392             IWineD3DVertexBufferImpl *vb = (IWineD3DVertexBufferImpl *) This->stateBlock->streamSource[strided.u.s.type.streamNo]; \
4393             strided.u.s.type.VBO = 0; \
4394             strided.u.s.type.lpData = (BYTE *) ((unsigned long) strided.u.s.type.lpData + (unsigned long) vb->resource.allocatedMemory); \
4395             ENTER_GL(); \
4396             GL_EXTCALL(glDeleteBuffersARB(1, &vb->vbo)); \
4397             vb->vbo = 0; \
4398             LEAVE_GL(); \
4399         } \
4400         if(strided.u.s.type.lpData) { \
4401             strided.u.s.type.lpData += strided.u.s.type.dwStride * SrcStartIndex; \
4402         }
4403         FIXSRC(position);
4404         FIXSRC(blendWeights);
4405         FIXSRC(blendMatrixIndices);
4406         FIXSRC(normal);
4407         FIXSRC(pSize);
4408         FIXSRC(diffuse);
4409         FIXSRC(specular);
4410         for(i = 0; i < WINED3DDP_MAXTEXCOORD; i++) {
4411             FIXSRC(texCoords[i]);
4412         }
4413         FIXSRC(position2);
4414         FIXSRC(normal2);
4415         FIXSRC(tangent);
4416         FIXSRC(binormal);
4417         FIXSRC(tessFactor);
4418         FIXSRC(fog);
4419         FIXSRC(depth);
4420         FIXSRC(sample);
4421 #undef FIXSRC
4422     }
4423
4424     return process_vertices_strided(This, DestIndex, VertexCount, &strided, (IWineD3DVertexBufferImpl *) pDestBuffer, Flags);
4425 }
4426
4427 /*****
4428  * Get / Set Texture Stage States
4429  * TODO: Verify against dx9 definitions
4430  *****/
4431 static HRESULT WINAPI IWineD3DDeviceImpl_SetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
4432     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4433     DWORD oldValue = This->updateStateBlock->textureState[Stage][Type];
4434
4435     TRACE("(%p) : Stage=%d, Type=%s(%d), Value=%d\n", This, Stage, debug_d3dtexturestate(Type), Type, Value);
4436
4437     if (Stage >= MAX_TEXTURES) {
4438         WARN("Attempting to set stage %u which is higher than the max stage %u, ignoring\n", Stage, MAX_TEXTURES - 1);
4439         return WINED3D_OK;
4440     }
4441
4442     This->updateStateBlock->changed.textureState[Stage][Type] = TRUE;
4443     This->updateStateBlock->textureState[Stage][Type]         = Value;
4444
4445     if (This->isRecordingState) {
4446         TRACE("Recording... not performing anything\n");
4447         return WINED3D_OK;
4448     }
4449
4450     /* Checked after the assignments to allow proper stateblock recording */
4451     if(oldValue == Value) {
4452         TRACE("App is setting the old value over, nothing to do\n");
4453         return WINED3D_OK;
4454     }
4455
4456     if(Stage > This->stateBlock->lowest_disabled_stage &&
4457        This->StateTable[STATE_TEXTURESTAGE(0, Type)].representative == STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP)) {
4458         /* Colorop change above lowest disabled stage? That won't change anything in the gl setup
4459          * Changes in other states are important on disabled stages too
4460          */
4461         return WINED3D_OK;
4462     }
4463
4464     if(Type == WINED3DTSS_COLOROP) {
4465         int i;
4466
4467         if(Value == WINED3DTOP_DISABLE && oldValue != WINED3DTOP_DISABLE) {
4468             /* Previously enabled stage disabled now. Make sure to dirtify all enabled stages above Stage,
4469              * they have to be disabled
4470              *
4471              * The current stage is dirtified below.
4472              */
4473             for(i = Stage + 1; i < This->stateBlock->lowest_disabled_stage; i++) {
4474                 TRACE("Additionally dirtifying stage %d\n", i);
4475                 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4476             }
4477             This->stateBlock->lowest_disabled_stage = Stage;
4478             TRACE("New lowest disabled: %d\n", Stage);
4479         } else if(Value != WINED3DTOP_DISABLE && oldValue == WINED3DTOP_DISABLE) {
4480             /* Previously disabled stage enabled. Stages above it may need enabling
4481              * stage must be lowest_disabled_stage here, if it's bigger success is returned above,
4482              * and stages below the lowest disabled stage can't be enabled(because they are enabled already).
4483              *
4484              * Again stage Stage doesn't need to be dirtified here, it is handled below.
4485              */
4486
4487             for(i = Stage + 1; i < GL_LIMITS(texture_stages); i++) {
4488                 if(This->updateStateBlock->textureState[i][WINED3DTSS_COLOROP] == WINED3DTOP_DISABLE) {
4489                     break;
4490                 }
4491                 TRACE("Additionally dirtifying stage %d due to enable\n", i);
4492                 IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP));
4493             }
4494             This->stateBlock->lowest_disabled_stage = i;
4495             TRACE("New lowest disabled: %d\n", i);
4496         }
4497     }
4498
4499     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, Type));
4500
4501     return WINED3D_OK;
4502 }
4503
4504 static HRESULT WINAPI IWineD3DDeviceImpl_GetTextureStageState(IWineD3DDevice *iface, DWORD Stage, WINED3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) {
4505     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4506     TRACE("(%p) : requesting Stage %d, Type %d getting %d\n", This, Stage, Type, This->updateStateBlock->textureState[Stage][Type]);
4507     *pValue = This->updateStateBlock->textureState[Stage][Type];
4508     return WINED3D_OK;
4509 }
4510
4511 /*****
4512  * Get / Set Texture
4513  *****/
4514 static HRESULT WINAPI IWineD3DDeviceImpl_SetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture* pTexture) {
4515     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4516     IWineD3DBaseTexture *oldTexture;
4517
4518     TRACE("(%p) : Stage %#x, Texture %p\n", This, Stage, pTexture);
4519
4520     if (Stage >= WINED3DVERTEXTEXTURESAMPLER0 && Stage <= WINED3DVERTEXTEXTURESAMPLER3) {
4521         Stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4522     }
4523
4524     if (Stage >= sizeof(This->stateBlock->textures)/sizeof(This->stateBlock->textures[0])) {
4525         ERR("Current stage overflows textures array (stage %d)\n", Stage);
4526         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
4527     }
4528
4529     oldTexture = This->updateStateBlock->textures[Stage];
4530
4531     /* SetTexture isn't allowed on textures in WINED3DPOOL_SCRATCH */
4532     if (pTexture && ((IWineD3DTextureImpl*)pTexture)->resource.pool == WINED3DPOOL_SCRATCH)
4533     {
4534         WARN("(%p) Attempt to set scratch texture rejected\n", pTexture);
4535         return WINED3DERR_INVALIDCALL;
4536     }
4537
4538     TRACE("GL_LIMITS %d\n",GL_LIMITS(sampler_stages));
4539     TRACE("(%p) : oldtexture(%p)\n", This,oldTexture);
4540
4541     This->updateStateBlock->changed.textures[Stage] = TRUE;
4542     TRACE("(%p) : setting new texture to %p\n", This, pTexture);
4543     This->updateStateBlock->textures[Stage]         = pTexture;
4544
4545     /* Handle recording of state blocks */
4546     if (This->isRecordingState) {
4547         TRACE("Recording... not performing anything\n");
4548         return WINED3D_OK;
4549     }
4550
4551     if(oldTexture == pTexture) {
4552         TRACE("App is setting the same texture again, nothing to do\n");
4553         return WINED3D_OK;
4554     }
4555
4556     /** NOTE: MSDN says that setTexture increases the reference count,
4557     * and that the application must set the texture back to null (or have a leaky application),
4558     * This means we should pass the refcount up to the parent
4559      *******************************/
4560     if (NULL != This->updateStateBlock->textures[Stage]) {
4561         IWineD3DBaseTextureImpl *new = (IWineD3DBaseTextureImpl *) This->updateStateBlock->textures[Stage];
4562         ULONG bindCount = InterlockedIncrement(&new->baseTexture.bindCount);
4563
4564         IWineD3DBaseTexture_AddRef(This->updateStateBlock->textures[Stage]);
4565         if(oldTexture == NULL && Stage < MAX_TEXTURES) {
4566             /* The source arguments for color and alpha ops have different meanings when a NULL texture is bound,
4567              * so the COLOROP and ALPHAOP have to be dirtified.
4568              */
4569             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_COLOROP));
4570             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_ALPHAOP));
4571         }
4572         if(bindCount == 1) {
4573             new->baseTexture.sampler = Stage;
4574         }
4575         /* More than one assignment? Doesn't matter, we only need one gl texture unit to use for uploading */
4576
4577     }
4578
4579     if (NULL != oldTexture) {
4580         IWineD3DBaseTextureImpl *old = (IWineD3DBaseTextureImpl *) oldTexture;
4581         LONG bindCount = InterlockedDecrement(&old->baseTexture.bindCount);
4582
4583         IWineD3DBaseTexture_Release(oldTexture);
4584         if(pTexture == NULL && Stage < MAX_TEXTURES) {
4585             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_COLOROP));
4586             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_TEXTURESTAGE(Stage, WINED3DTSS_ALPHAOP));
4587         }
4588
4589         if(bindCount && old->baseTexture.sampler == Stage) {
4590             int i;
4591             /* Have to do a search for the other sampler(s) where the texture is bound to
4592              * Shouldn't happen as long as apps bind a texture only to one stage
4593              */
4594             TRACE("Searcing for other sampler / stage id where the texture is bound to\n");
4595             for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
4596                 if(This->updateStateBlock->textures[i] == oldTexture) {
4597                     old->baseTexture.sampler = i;
4598                     break;
4599                 }
4600             }
4601         }
4602     }
4603
4604     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(Stage));
4605
4606     return WINED3D_OK;
4607 }
4608
4609 static HRESULT WINAPI IWineD3DDeviceImpl_GetTexture(IWineD3DDevice *iface, DWORD Stage, IWineD3DBaseTexture** ppTexture) {
4610     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4611
4612     TRACE("(%p) : Stage %#x, ppTexture %p\n", This, Stage, ppTexture);
4613
4614     if (Stage >= WINED3DVERTEXTEXTURESAMPLER0 && Stage <= WINED3DVERTEXTEXTURESAMPLER3) {
4615         Stage -= (WINED3DVERTEXTEXTURESAMPLER0 - MAX_FRAGMENT_SAMPLERS);
4616     }
4617
4618     if (Stage >= sizeof(This->stateBlock->textures)/sizeof(This->stateBlock->textures[0])) {
4619         ERR("Current stage overflows textures array (stage %d)\n", Stage);
4620         return WINED3D_OK; /* Windows accepts overflowing this array ... we do not. */
4621     }
4622
4623     *ppTexture=This->stateBlock->textures[Stage];
4624     if (*ppTexture)
4625         IWineD3DBaseTexture_AddRef(*ppTexture);
4626
4627     TRACE("(%p) : Returning %p\n", This, *ppTexture);
4628
4629     return WINED3D_OK;
4630 }
4631
4632 /*****
4633  * Get Back Buffer
4634  *****/
4635 static HRESULT WINAPI IWineD3DDeviceImpl_GetBackBuffer(IWineD3DDevice *iface, UINT iSwapChain, UINT BackBuffer, WINED3DBACKBUFFER_TYPE Type,
4636                                                 IWineD3DSurface **ppBackBuffer) {
4637     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4638     IWineD3DSwapChain *swapChain;
4639     HRESULT hr;
4640
4641     TRACE("(%p) : BackBuf %d Type %d SwapChain %d returning %p\n", This, BackBuffer, Type, iSwapChain, *ppBackBuffer);
4642
4643     hr = IWineD3DDeviceImpl_GetSwapChain(iface,  iSwapChain, &swapChain);
4644     if (hr == WINED3D_OK) {
4645         hr = IWineD3DSwapChain_GetBackBuffer(swapChain, BackBuffer, Type, ppBackBuffer);
4646             IWineD3DSwapChain_Release(swapChain);
4647     } else {
4648         *ppBackBuffer = NULL;
4649     }
4650     return hr;
4651 }
4652
4653 static HRESULT WINAPI IWineD3DDeviceImpl_GetDeviceCaps(IWineD3DDevice *iface, WINED3DCAPS* pCaps) {
4654     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4655     WARN("(%p) : stub, calling idirect3d for now\n", This);
4656     return IWineD3D_GetDeviceCaps(This->wineD3D, This->adapterNo, This->devType, pCaps);
4657 }
4658
4659 static HRESULT WINAPI IWineD3DDeviceImpl_GetDisplayMode(IWineD3DDevice *iface, UINT iSwapChain, WINED3DDISPLAYMODE* pMode) {
4660     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4661     IWineD3DSwapChain *swapChain;
4662     HRESULT hr;
4663
4664     if(iSwapChain > 0) {
4665         hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
4666         if (hr == WINED3D_OK) {
4667             hr = IWineD3DSwapChain_GetDisplayMode(swapChain, pMode);
4668             IWineD3DSwapChain_Release(swapChain);
4669         } else {
4670             FIXME("(%p) Error getting display mode\n", This);
4671         }
4672     } else {
4673         /* Don't read the real display mode,
4674            but return the stored mode instead. X11 can't change the color
4675            depth, and some apps are pretty angry if they SetDisplayMode from
4676            24 to 16 bpp and find out that GetDisplayMode still returns 24 bpp
4677
4678            Also don't relay to the swapchain because with ddraw it's possible
4679            that there isn't a swapchain at all */
4680         pMode->Width = This->ddraw_width;
4681         pMode->Height = This->ddraw_height;
4682         pMode->Format = This->ddraw_format;
4683         pMode->RefreshRate = 0;
4684         hr = WINED3D_OK;
4685     }
4686
4687     return hr;
4688 }
4689
4690 /*****
4691  * Stateblock related functions
4692  *****/
4693
4694 static HRESULT WINAPI IWineD3DDeviceImpl_BeginStateBlock(IWineD3DDevice *iface) {
4695     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4696     IWineD3DStateBlockImpl *object;
4697     HRESULT temp_result;
4698     int i;
4699
4700     TRACE("(%p)\n", This);
4701
4702     if (This->isRecordingState) {
4703         return WINED3DERR_INVALIDCALL;
4704     }
4705
4706     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DStateBlockImpl));
4707     if (NULL == object ) {
4708         FIXME("(%p)Error allocating memory for stateblock\n", This);
4709         return E_OUTOFMEMORY;
4710     }
4711     TRACE("(%p) created object %p\n", This, object);
4712     object->wineD3DDevice= This;
4713     /** FIXME: object->parent       = parent; **/
4714     object->parent       = NULL;
4715     object->blockType    = WINED3DSBT_RECORDED;
4716     object->ref          = 1;
4717     object->lpVtbl       = &IWineD3DStateBlock_Vtbl;
4718
4719     for(i = 0; i < LIGHTMAP_SIZE; i++) {
4720         list_init(&object->lightMap[i]);
4721     }
4722
4723     temp_result = allocate_shader_constants(object);
4724     if (WINED3D_OK != temp_result)
4725         return temp_result;
4726
4727     IWineD3DStateBlock_Release((IWineD3DStateBlock*)This->updateStateBlock);
4728     This->updateStateBlock = object;
4729     This->isRecordingState = TRUE;
4730
4731     TRACE("(%p) recording stateblock %p\n",This , object);
4732     return WINED3D_OK;
4733 }
4734
4735 static HRESULT WINAPI IWineD3DDeviceImpl_EndStateBlock(IWineD3DDevice *iface, IWineD3DStateBlock** ppStateBlock) {
4736     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4737     unsigned int i, j;
4738     IWineD3DStateBlockImpl *object = This->updateStateBlock;
4739
4740     if (!This->isRecordingState) {
4741         FIXME("(%p) not recording! returning error\n", This);
4742         *ppStateBlock = NULL;
4743         return WINED3DERR_INVALIDCALL;
4744     }
4745
4746     for(i = 1; i <= WINEHIGHEST_RENDER_STATE; i++) {
4747         if(object->changed.renderState[i]) {
4748             object->contained_render_states[object->num_contained_render_states] = i;
4749             object->num_contained_render_states++;
4750         }
4751     }
4752     for(i = 1; i <= HIGHEST_TRANSFORMSTATE; i++) {
4753         if(object->changed.transform[i]) {
4754             object->contained_transform_states[object->num_contained_transform_states] = i;
4755             object->num_contained_transform_states++;
4756         }
4757     }
4758     for(i = 0; i < GL_LIMITS(vshader_constantsF); i++) {
4759         if(object->changed.vertexShaderConstantsF[i]) {
4760             object->contained_vs_consts_f[object->num_contained_vs_consts_f] = i;
4761             object->num_contained_vs_consts_f++;
4762         }
4763     }
4764     for(i = 0; i < MAX_CONST_I; i++) {
4765         if (object->changed.vertexShaderConstantsI & (1 << i))
4766         {
4767             object->contained_vs_consts_i[object->num_contained_vs_consts_i] = i;
4768             object->num_contained_vs_consts_i++;
4769         }
4770     }
4771     for(i = 0; i < MAX_CONST_B; i++) {
4772         if (object->changed.vertexShaderConstantsB & (1 << i))
4773         {
4774             object->contained_vs_consts_b[object->num_contained_vs_consts_b] = i;
4775             object->num_contained_vs_consts_b++;
4776         }
4777     }
4778     for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i)
4779     {
4780         if (object->changed.pixelShaderConstantsF[i])
4781         {
4782             object->contained_ps_consts_f[object->num_contained_ps_consts_f] = i;
4783             ++object->num_contained_ps_consts_f;
4784         }
4785     }
4786     for(i = 0; i < MAX_CONST_I; i++) {
4787         if (object->changed.pixelShaderConstantsI & (1 << i))
4788         {
4789             object->contained_ps_consts_i[object->num_contained_ps_consts_i] = i;
4790             object->num_contained_ps_consts_i++;
4791         }
4792     }
4793     for(i = 0; i < MAX_CONST_B; i++) {
4794         if (object->changed.pixelShaderConstantsB & (1 << i))
4795         {
4796             object->contained_ps_consts_b[object->num_contained_ps_consts_b] = i;
4797             object->num_contained_ps_consts_b++;
4798         }
4799     }
4800     for(i = 0; i < MAX_TEXTURES; i++) {
4801         for(j = 1; j <= WINED3D_HIGHEST_TEXTURE_STATE; j++) {
4802             if(object->changed.textureState[i][j]) {
4803                 object->contained_tss_states[object->num_contained_tss_states].stage = i;
4804                 object->contained_tss_states[object->num_contained_tss_states].state = j;
4805                 object->num_contained_tss_states++;
4806             }
4807         }
4808     }
4809     for(i = 0; i < MAX_COMBINED_SAMPLERS; i++){
4810         for (j = 1; j < WINED3D_HIGHEST_SAMPLER_STATE; j++) {
4811             if(object->changed.samplerState[i][j]) {
4812                 object->contained_sampler_states[object->num_contained_sampler_states].stage = i;
4813                 object->contained_sampler_states[object->num_contained_sampler_states].state = j;
4814                 object->num_contained_sampler_states++;
4815             }
4816         }
4817     }
4818
4819     *ppStateBlock = (IWineD3DStateBlock*) object;
4820     This->isRecordingState = FALSE;
4821     This->updateStateBlock = This->stateBlock;
4822     IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)This->updateStateBlock);
4823     /* IWineD3DStateBlock_AddRef(*ppStateBlock); don't need to do this, since we should really just release UpdateStateBlock first */
4824     TRACE("(%p) returning token (ptr to stateblock) of %p\n", This, *ppStateBlock);
4825     return WINED3D_OK;
4826 }
4827
4828 /*****
4829  * Scene related functions
4830  *****/
4831 static HRESULT WINAPI IWineD3DDeviceImpl_BeginScene(IWineD3DDevice *iface) {
4832     /* At the moment we have no need for any functionality at the beginning
4833        of a scene                                                          */
4834     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4835     TRACE("(%p)\n", This);
4836
4837     if(This->inScene) {
4838         TRACE("Already in Scene, returning WINED3DERR_INVALIDCALL\n");
4839         return WINED3DERR_INVALIDCALL;
4840     }
4841     This->inScene = TRUE;
4842     return WINED3D_OK;
4843 }
4844
4845 static HRESULT WINAPI IWineD3DDeviceImpl_EndScene(IWineD3DDevice *iface) {
4846     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4847     TRACE("(%p)\n", This);
4848
4849     if(!This->inScene) {
4850         TRACE("Not in scene, returning WINED3DERR_INVALIDCALL\n");
4851         return WINED3DERR_INVALIDCALL;
4852     }
4853
4854     ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
4855     /* We only have to do this if we need to read the, swapbuffers performs a flush for us */
4856     glFlush();
4857     /* No checkGLcall here to avoid locking the lock just for checking a call that hardly ever
4858      * fails
4859      */
4860
4861     This->inScene = FALSE;
4862     return WINED3D_OK;
4863 }
4864
4865 static HRESULT WINAPI IWineD3DDeviceImpl_Present(IWineD3DDevice *iface,
4866                                           CONST RECT* pSourceRect, CONST RECT* pDestRect,
4867                                           HWND hDestWindowOverride, CONST RGNDATA* pDirtyRegion) {
4868     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
4869     IWineD3DSwapChain *swapChain = NULL;
4870     int i;
4871     int swapchains = IWineD3DDeviceImpl_GetNumberOfSwapChains(iface);
4872
4873     TRACE("(%p) Presenting the frame\n", This);
4874
4875     for(i = 0 ; i < swapchains ; i ++) {
4876
4877         IWineD3DDeviceImpl_GetSwapChain(iface, i, &swapChain);
4878         TRACE("presentinng chain %d, %p\n", i, swapChain);
4879         IWineD3DSwapChain_Present(swapChain, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, 0);
4880         IWineD3DSwapChain_Release(swapChain);
4881     }
4882
4883     return WINED3D_OK;
4884 }
4885
4886 /* Not called from the VTable (internal subroutine) */
4887 HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl *This,  IWineD3DSurfaceImpl *target, DWORD Count,
4888                                         CONST WINED3DRECT* pRects, DWORD Flags, WINED3DCOLOR Color,
4889                                         float Z, DWORD Stencil) {
4890     GLbitfield     glMask = 0;
4891     unsigned int   i;
4892     WINED3DRECT curRect;
4893     RECT vp_rect;
4894     const WINED3DVIEWPORT *vp = &This->stateBlock->viewport;
4895     UINT drawable_width, drawable_height;
4896     IWineD3DSurfaceImpl *depth_stencil = (IWineD3DSurfaceImpl *) This->stencilBufferTarget;
4897     IWineD3DSwapChainImpl *swapchain = NULL;
4898
4899     /* When we're clearing parts of the drawable, make sure that the target surface is well up to date in the
4900      * drawable. After the clear we'll mark the drawable up to date, so we have to make sure that this is true
4901      * for the cleared parts, and the untouched parts.
4902      *
4903      * If we're clearing the whole target there is no need to copy it into the drawable, it will be overwritten
4904      * anyway. If we're not clearing the color buffer we don't have to copy either since we're not going to set
4905      * the drawable up to date. We have to check all settings that limit the clear area though. Do not bother
4906      * checking all this if the dest surface is in the drawable anyway.
4907      */
4908     if((Flags & WINED3DCLEAR_TARGET) && !(target->Flags & SFLAG_INDRAWABLE)) {
4909         while(1) {
4910             if(vp->X != 0 || vp->Y != 0 ||
4911                vp->Width < target->currentDesc.Width || vp->Height < target->currentDesc.Height) {
4912                 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4913                 break;
4914             }
4915             if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
4916                This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
4917                This->stateBlock->scissorRect.right < target->currentDesc.Width ||
4918                This->stateBlock->scissorRect.bottom < target->currentDesc.Height)) {
4919                 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4920                 break;
4921             }
4922             if(Count > 0 && pRects && (
4923                pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
4924                pRects[0].x2 < target->currentDesc.Width ||
4925                pRects[0].y2 < target->currentDesc.Height)) {
4926                 IWineD3DSurface_LoadLocation((IWineD3DSurface *) target, SFLAG_INDRAWABLE, NULL);
4927                 break;
4928             }
4929             break;
4930         }
4931     }
4932
4933     target->get_drawable_size(target, &drawable_width, &drawable_height);
4934
4935     ActivateContext(This, (IWineD3DSurface *) target, CTXUSAGE_CLEAR);
4936     ENTER_GL();
4937
4938     /* Only set the values up once, as they are not changing */
4939     if (Flags & WINED3DCLEAR_STENCIL) {
4940         glClearStencil(Stencil);
4941         checkGLcall("glClearStencil");
4942         glMask = glMask | GL_STENCIL_BUFFER_BIT;
4943         glStencilMask(0xFFFFFFFF);
4944     }
4945
4946     if (Flags & WINED3DCLEAR_ZBUFFER) {
4947         DWORD location = This->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
4948         glDepthMask(GL_TRUE);
4949         glClearDepth(Z);
4950         checkGLcall("glClearDepth");
4951         glMask = glMask | GL_DEPTH_BUFFER_BIT;
4952         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
4953
4954         if (vp->X != 0 || vp->Y != 0 ||
4955                 vp->Width < depth_stencil->currentDesc.Width || vp->Height < depth_stencil->currentDesc.Height) {
4956             surface_load_ds_location(This->stencilBufferTarget, location);
4957         }
4958         else if (This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE] && (
4959                 This->stateBlock->scissorRect.left > 0 || This->stateBlock->scissorRect.top > 0 ||
4960                 This->stateBlock->scissorRect.right < depth_stencil->currentDesc.Width ||
4961                 This->stateBlock->scissorRect.bottom < depth_stencil->currentDesc.Height)) {
4962             surface_load_ds_location(This->stencilBufferTarget, location);
4963         }
4964         else if (Count > 0 && pRects && (
4965                 pRects[0].x1 > 0 || pRects[0].y1 > 0 ||
4966                 pRects[0].x2 < depth_stencil->currentDesc.Width ||
4967                 pRects[0].y2 < depth_stencil->currentDesc.Height)) {
4968             surface_load_ds_location(This->stencilBufferTarget, location);
4969         }
4970     }
4971
4972     if (Flags & WINED3DCLEAR_TARGET) {
4973         TRACE("Clearing screen with glClear to color %x\n", Color);
4974         glClearColor(D3DCOLOR_R(Color),
4975                      D3DCOLOR_G(Color),
4976                      D3DCOLOR_B(Color),
4977                      D3DCOLOR_A(Color));
4978         checkGLcall("glClearColor");
4979
4980         /* Clear ALL colors! */
4981         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
4982         glMask = glMask | GL_COLOR_BUFFER_BIT;
4983     }
4984
4985     vp_rect.left = vp->X;
4986     vp_rect.top = vp->Y;
4987     vp_rect.right = vp->X + vp->Width;
4988     vp_rect.bottom = vp->Y + vp->Height;
4989     if (!(Count > 0 && pRects)) {
4990         if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
4991             IntersectRect(&vp_rect, &vp_rect, &This->stateBlock->scissorRect);
4992         }
4993         if(This->render_offscreen) {
4994             glScissor(vp_rect.left, vp_rect.top,
4995                         vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
4996         } else {
4997             glScissor(vp_rect.left, drawable_height - vp_rect.bottom,
4998                         vp_rect.right - vp_rect.left, vp_rect.bottom - vp_rect.top);
4999         }
5000         checkGLcall("glScissor");
5001         glClear(glMask);
5002         checkGLcall("glClear");
5003     } else {
5004         /* Now process each rect in turn */
5005         for (i = 0; i < Count; i++) {
5006             /* Note gl uses lower left, width/height */
5007             IntersectRect((RECT *)&curRect, &vp_rect, (const RECT *)&pRects[i]);
5008             if(This->stateBlock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
5009                 IntersectRect((RECT *) &curRect, (RECT *) &curRect, &This->stateBlock->scissorRect);
5010             }
5011             TRACE("(%p) Rect=(%d,%d)->(%d,%d) glRect=(%d,%d), len=%d, hei=%d\n", This,
5012                   pRects[i].x1, pRects[i].y1, pRects[i].x2, pRects[i].y2,
5013                   curRect.x1, (target->currentDesc.Height - curRect.y2),
5014                   curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5015
5016             /* Tests show that rectangles where x1 > x2 or y1 > y2 are ignored silently.
5017              * The rectangle is not cleared, no error is returned, but further rectanlges are
5018              * still cleared if they are valid
5019              */
5020             if(curRect.x1 > curRect.x2 || curRect.y1 > curRect.y2) {
5021                 TRACE("Rectangle with negative dimensions, ignoring\n");
5022                 continue;
5023             }
5024
5025             if(This->render_offscreen) {
5026                 glScissor(curRect.x1, curRect.y1,
5027                           curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5028             } else {
5029                 glScissor(curRect.x1, drawable_height - curRect.y2,
5030                           curRect.x2 - curRect.x1, curRect.y2 - curRect.y1);
5031             }
5032             checkGLcall("glScissor");
5033
5034             glClear(glMask);
5035             checkGLcall("glClear");
5036         }
5037     }
5038
5039     /* Restore the old values (why..?) */
5040     if (Flags & WINED3DCLEAR_STENCIL) {
5041         glStencilMask(This->stateBlock->renderState[WINED3DRS_STENCILWRITEMASK]);
5042     }
5043     if (Flags & WINED3DCLEAR_TARGET) {
5044         DWORD mask = This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE];
5045         glColorMask(mask & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
5046                     mask & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
5047                     mask & WINED3DCOLORWRITEENABLE_BLUE  ? GL_TRUE : GL_FALSE,
5048                     mask & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
5049
5050         /* Dirtify the target surface for now. If the surface is locked regularly, and an up to date sysmem copy exists,
5051          * it is most likely more efficient to perform a clear on the sysmem copy too instead of downloading it
5052          */
5053         IWineD3DSurface_ModifyLocation(This->lastActiveRenderTarget, SFLAG_INDRAWABLE, TRUE);
5054     }
5055     if (Flags & WINED3DCLEAR_ZBUFFER) {
5056         /* Note that WINED3DCLEAR_ZBUFFER implies a depth stencil exists on the device */
5057         DWORD location = This->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
5058         surface_modify_ds_location(This->stencilBufferTarget, location);
5059     }
5060
5061     LEAVE_GL();
5062
5063     if (SUCCEEDED(IWineD3DSurface_GetContainer((IWineD3DSurface *)target, &IID_IWineD3DSwapChain, (void **)&swapchain))) {
5064         if (target == (IWineD3DSurfaceImpl*) swapchain->frontBuffer) {
5065             glFlush();
5066         }
5067         IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
5068     }
5069
5070     return WINED3D_OK;
5071 }
5072
5073 static HRESULT WINAPI IWineD3DDeviceImpl_Clear(IWineD3DDevice *iface, DWORD Count, CONST WINED3DRECT* pRects,
5074                                         DWORD Flags, WINED3DCOLOR Color, float Z, DWORD Stencil) {
5075     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5076     IWineD3DSurfaceImpl *target = (IWineD3DSurfaceImpl *)This->render_targets[0];
5077
5078     TRACE("(%p) Count (%d), pRects (%p), Flags (%x), Color (0x%08x), Z (%f), Stencil (%d)\n", This,
5079           Count, pRects, Flags, Color, Z, Stencil);
5080
5081     if(Flags & (WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL) && This->stencilBufferTarget == NULL) {
5082         WARN("Clearing depth and/or stencil without a depth stencil buffer attached, returning WINED3DERR_INVALIDCALL\n");
5083         /* TODO: What about depth stencil buffers without stencil bits? */
5084         return WINED3DERR_INVALIDCALL;
5085     }
5086
5087     return IWineD3DDeviceImpl_ClearSurface(This, target, Count, pRects, Flags, Color, Z, Stencil);
5088 }
5089
5090 /*****
5091  * Drawing functions
5092  *****/
5093 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitive(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType, UINT StartVertex,
5094                                                 UINT PrimitiveCount) {
5095
5096     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5097
5098     TRACE("(%p) : Type=(%d,%s), Start=%d, Count=%d\n", This, PrimitiveType,
5099                                debug_d3dprimitivetype(PrimitiveType),
5100                                StartVertex, PrimitiveCount);
5101
5102     if(!This->stateBlock->vertexDecl) {
5103         WARN("(%p) : Called without a valid vertex declaration set\n", This);
5104         return WINED3DERR_INVALIDCALL;
5105     }
5106
5107     /* The index buffer is not needed here, but restore it, otherwise it is hell to keep track of */
5108     if(This->stateBlock->streamIsUP) {
5109         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5110         This->stateBlock->streamIsUP = FALSE;
5111     }
5112
5113     if(This->stateBlock->loadBaseVertexIndex != 0) {
5114         This->stateBlock->loadBaseVertexIndex = 0;
5115         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5116     }
5117     /* Account for the loading offset due to index buffers. Instead of reloading all sources correct it with the startvertex parameter */
5118     drawPrimitive(iface, PrimitiveType, PrimitiveCount, StartVertex, 0/* NumVertices */, -1 /* indxStart */,
5119                   0 /* indxSize */, NULL /* indxData */, 0 /* minIndex */);
5120     return WINED3D_OK;
5121 }
5122
5123 /* TODO: baseVIndex needs to be provided from This->stateBlock->baseVertexIndex when called from d3d8 */
5124 static HRESULT  WINAPI  IWineD3DDeviceImpl_DrawIndexedPrimitive(IWineD3DDevice *iface,
5125                                                            WINED3DPRIMITIVETYPE PrimitiveType,
5126                                                            UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount) {
5127
5128     IWineD3DDeviceImpl  *This = (IWineD3DDeviceImpl *)iface;
5129     UINT                 idxStride = 2;
5130     IWineD3DIndexBuffer *pIB;
5131     WINED3DINDEXBUFFER_DESC  IdxBufDsc;
5132     GLuint vbo;
5133
5134     pIB = This->stateBlock->pIndexData;
5135     if (!pIB) {
5136         /* D3D9 returns D3DERR_INVALIDCALL when DrawIndexedPrimitive is called
5137          * without an index buffer set. (The first time at least...)
5138          * D3D8 simply dies, but I doubt it can do much harm to return
5139          * D3DERR_INVALIDCALL there as well. */
5140         ERR("(%p) : Called without a valid index buffer set, returning WINED3DERR_INVALIDCALL\n", This);
5141         return WINED3DERR_INVALIDCALL;
5142     }
5143
5144     if(!This->stateBlock->vertexDecl) {
5145         WARN("(%p) : Called without a valid vertex declaration set\n", This);
5146         return WINED3DERR_INVALIDCALL;
5147     }
5148
5149     if(This->stateBlock->streamIsUP) {
5150         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5151         This->stateBlock->streamIsUP = FALSE;
5152     }
5153     vbo = ((IWineD3DIndexBufferImpl *) pIB)->vbo;
5154
5155     TRACE("(%p) : Type=(%d,%s), min=%d, CountV=%d, startIdx=%d, countP=%d\n", This,
5156           PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5157           minIndex, NumVertices, startIndex, primCount);
5158
5159     IWineD3DIndexBuffer_GetDesc(pIB, &IdxBufDsc);
5160     if (IdxBufDsc.Format == WINED3DFMT_INDEX16) {
5161         idxStride = 2;
5162     } else {
5163         idxStride = 4;
5164     }
5165
5166     if(This->stateBlock->loadBaseVertexIndex != This->stateBlock->baseVertexIndex) {
5167         This->stateBlock->loadBaseVertexIndex = This->stateBlock->baseVertexIndex;
5168         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5169     }
5170
5171     drawPrimitive(iface, PrimitiveType, primCount, 0, NumVertices, startIndex,
5172                    idxStride, vbo ? NULL : ((IWineD3DIndexBufferImpl *) pIB)->resource.allocatedMemory, minIndex);
5173
5174     return WINED3D_OK;
5175 }
5176
5177 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveUP(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType,
5178                                                     UINT PrimitiveCount, CONST void* pVertexStreamZeroData,
5179                                                     UINT VertexStreamZeroStride) {
5180     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5181     IWineD3DVertexBuffer *vb;
5182
5183     TRACE("(%p) : Type=(%d,%s), pCount=%d, pVtxData=%p, Stride=%d\n", This, PrimitiveType,
5184              debug_d3dprimitivetype(PrimitiveType),
5185              PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
5186
5187     if(!This->stateBlock->vertexDecl) {
5188         WARN("(%p) : Called without a valid vertex declaration set\n", This);
5189         return WINED3DERR_INVALIDCALL;
5190     }
5191
5192     /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5193     vb = This->stateBlock->streamSource[0];
5194     This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5195     if(vb) IWineD3DVertexBuffer_Release(vb);
5196     This->stateBlock->streamOffset[0] = 0;
5197     This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5198     This->stateBlock->streamIsUP = TRUE;
5199     This->stateBlock->loadBaseVertexIndex = 0;
5200
5201     /* TODO: Only mark dirty if drawing from a different UP address */
5202     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_STREAMSRC);
5203
5204     drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* start vertex */, 0  /* NumVertices */,
5205                   0 /* indxStart*/, 0 /* indxSize*/, NULL /* indxData */, 0 /* indxMin */);
5206
5207     /* MSDN specifies stream zero settings must be set to NULL */
5208     This->stateBlock->streamStride[0] = 0;
5209     This->stateBlock->streamSource[0] = NULL;
5210
5211     /* stream zero settings set to null at end, as per the msdn. No need to mark dirty here, the app has to set
5212      * the new stream sources or use UP drawing again
5213      */
5214     return WINED3D_OK;
5215 }
5216
5217 static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveUP(IWineD3DDevice *iface, WINED3DPRIMITIVETYPE PrimitiveType,
5218                                                              UINT MinVertexIndex, UINT NumVertices,
5219                                                              UINT PrimitiveCount, CONST void* pIndexData,
5220                                                              WINED3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,
5221                                                              UINT VertexStreamZeroStride) {
5222     int                 idxStride;
5223     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5224     IWineD3DVertexBuffer *vb;
5225     IWineD3DIndexBuffer *ib;
5226
5227     TRACE("(%p) : Type=(%d,%s), MinVtxIdx=%d, NumVIdx=%d, PCount=%d, pidxdata=%p, IdxFmt=%d, pVtxdata=%p, stride=%d\n",
5228              This, PrimitiveType, debug_d3dprimitivetype(PrimitiveType),
5229              MinVertexIndex, NumVertices, PrimitiveCount, pIndexData,
5230              IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
5231
5232     if(!This->stateBlock->vertexDecl) {
5233         WARN("(%p) : Called without a valid vertex declaration set\n", This);
5234         return WINED3DERR_INVALIDCALL;
5235     }
5236
5237     if (IndexDataFormat == WINED3DFMT_INDEX16) {
5238         idxStride = 2;
5239     } else {
5240         idxStride = 4;
5241     }
5242
5243     /* Note in the following, it's not this type, but that's the purpose of streamIsUP */
5244     vb = This->stateBlock->streamSource[0];
5245     This->stateBlock->streamSource[0] = (IWineD3DVertexBuffer *)pVertexStreamZeroData;
5246     if(vb) IWineD3DVertexBuffer_Release(vb);
5247     This->stateBlock->streamIsUP = TRUE;
5248     This->stateBlock->streamOffset[0] = 0;
5249     This->stateBlock->streamStride[0] = VertexStreamZeroStride;
5250
5251     /* Set to 0 as per msdn. Do it now due to the stream source loading during drawPrimitive */
5252     This->stateBlock->baseVertexIndex = 0;
5253     This->stateBlock->loadBaseVertexIndex = 0;
5254     /* Mark the state dirty until we have nicer tracking of the stream source pointers */
5255     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5256     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5257
5258     drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* vertexStart */, NumVertices, 0 /* indxStart */, idxStride, pIndexData, MinVertexIndex);
5259
5260     /* MSDN specifies stream zero settings and index buffer must be set to NULL */
5261     This->stateBlock->streamSource[0] = NULL;
5262     This->stateBlock->streamStride[0] = 0;
5263     ib = This->stateBlock->pIndexData;
5264     if(ib) {
5265         IWineD3DIndexBuffer_Release(ib);
5266         This->stateBlock->pIndexData = NULL;
5267     }
5268     /* No need to mark the stream source state dirty here. Either the app calls UP drawing again, or it has to call
5269      * SetStreamSource to specify a vertex buffer
5270      */
5271
5272     return WINED3D_OK;
5273 }
5274
5275 static HRESULT WINAPI IWineD3DDeviceImpl_DrawPrimitiveStrided(IWineD3DDevice *iface,
5276         WINED3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount,
5277         const WineDirect3DVertexStridedData *DrawPrimStrideData)
5278 {
5279     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5280
5281     /* Mark the state dirty until we have nicer tracking
5282      * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
5283      * that value.
5284      */
5285     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5286     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5287     This->stateBlock->baseVertexIndex = 0;
5288     This->up_strided = DrawPrimStrideData;
5289     drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0, 0, 0, 0, NULL, 0);
5290     This->up_strided = NULL;
5291     return WINED3D_OK;
5292 }
5293
5294 static HRESULT WINAPI IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided(IWineD3DDevice *iface,
5295         WINED3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount,
5296         const WineDirect3DVertexStridedData *DrawPrimStrideData, UINT NumVertices, const void *pIndexData,
5297         WINED3DFORMAT IndexDataFormat)
5298 {
5299     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5300     DWORD idxSize = (IndexDataFormat == WINED3DFMT_INDEX32 ? 4 : 2);
5301
5302     /* Mark the state dirty until we have nicer tracking
5303      * its fine to change baseVertexIndex because that call is only called by ddraw which does not need
5304      * that value.
5305      */
5306     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VDECL);
5307     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_INDEXBUFFER);
5308     This->stateBlock->streamIsUP = TRUE;
5309     This->stateBlock->baseVertexIndex = 0;
5310     This->up_strided = DrawPrimStrideData;
5311     drawPrimitive(iface, PrimitiveType, PrimitiveCount, 0 /* startvertexidx */, 0 /* numindices */, 0 /* startidx */, idxSize, pIndexData, 0 /* minindex */);
5312     This->up_strided = NULL;
5313     return WINED3D_OK;
5314 }
5315
5316 static HRESULT IWineD3DDeviceImpl_UpdateVolume(IWineD3DDevice *iface, IWineD3DVolume *pSourceVolume, IWineD3DVolume *pDestinationVolume) {
5317     /* This is a helper function for UpdateTexture, there is no public UpdateVolume method in d3d. Since it's
5318      * not callable by the app directly no parameter validation checks are needed here.
5319      */
5320     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
5321     WINED3DLOCKED_BOX src;
5322     WINED3DLOCKED_BOX dst;
5323     HRESULT hr;
5324     TRACE("(%p)->(%p, %p)\n", This, pSourceVolume, pDestinationVolume);
5325
5326     /* TODO: Implement direct loading into the gl volume instead of using memcpy and
5327      * dirtification to improve loading performance.
5328      */
5329     hr = IWineD3DVolume_LockBox(pSourceVolume, &src, NULL, WINED3DLOCK_READONLY);
5330     if(FAILED(hr)) return hr;
5331     hr = IWineD3DVolume_LockBox(pDestinationVolume, &dst, NULL, WINED3DLOCK_DISCARD);
5332     if(FAILED(hr)) {
5333     IWineD3DVolume_UnlockBox(pSourceVolume);
5334             return hr;
5335     }
5336
5337     memcpy(dst.pBits, src.pBits, ((IWineD3DVolumeImpl *) pDestinationVolume)->resource.size);
5338
5339     hr = IWineD3DVolume_UnlockBox(pDestinationVolume);
5340     if(FAILED(hr)) {
5341         IWineD3DVolume_UnlockBox(pSourceVolume);
5342     } else {
5343         hr = IWineD3DVolume_UnlockBox(pSourceVolume);
5344     }
5345     return hr;
5346 }
5347
5348 /* Yet another way to update a texture, some apps use this to load default textures instead of using surface/texture lock/unlock */
5349 static HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture (IWineD3DDevice *iface, IWineD3DBaseTexture *pSourceTexture,  IWineD3DBaseTexture *pDestinationTexture){
5350     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5351     HRESULT hr = WINED3D_OK;
5352     WINED3DRESOURCETYPE sourceType;
5353     WINED3DRESOURCETYPE destinationType;
5354     int i ,levels;
5355
5356     /* TODO: think about moving the code into IWineD3DBaseTexture  */
5357
5358     TRACE("(%p) Source %p Destination %p\n", This, pSourceTexture, pDestinationTexture);
5359
5360     /* verify that the source and destination textures aren't NULL */
5361     if (NULL == pSourceTexture || NULL == pDestinationTexture) {
5362         WARN("(%p) : source (%p) and destination (%p) textures must not be NULL, returning WINED3DERR_INVALIDCALL\n",
5363              This, pSourceTexture, pDestinationTexture);
5364         hr = WINED3DERR_INVALIDCALL;
5365     }
5366
5367     if (pSourceTexture == pDestinationTexture) {
5368         WARN("(%p) : source (%p) and destination (%p) textures must be different, returning WINED3DERR_INVALIDCALL\n",
5369              This, pSourceTexture, pDestinationTexture);
5370         hr = WINED3DERR_INVALIDCALL;
5371     }
5372     /* Verify that the source and destination textures are the same type */
5373     sourceType      = IWineD3DBaseTexture_GetType(pSourceTexture);
5374     destinationType = IWineD3DBaseTexture_GetType(pDestinationTexture);
5375
5376     if (sourceType != destinationType) {
5377         WARN("(%p) Sorce and destination types must match, returning WINED3DERR_INVALIDCALL\n",
5378              This);
5379         hr = WINED3DERR_INVALIDCALL;
5380     }
5381
5382     /* check that both textures have the identical numbers of levels  */
5383     if (IWineD3DBaseTexture_GetLevelCount(pDestinationTexture)  != IWineD3DBaseTexture_GetLevelCount(pSourceTexture)) {
5384         WARN("(%p) : source (%p) and destination (%p) textures must have identical numbers of levels, returning WINED3DERR_INVALIDCALL\n", This, pSourceTexture, pDestinationTexture);
5385         hr = WINED3DERR_INVALIDCALL;
5386     }
5387
5388     if (WINED3D_OK == hr) {
5389
5390         /* Make sure that the destination texture is loaded */
5391         IWineD3DBaseTexture_PreLoad(pDestinationTexture);
5392
5393         /* Update every surface level of the texture */
5394         levels = IWineD3DBaseTexture_GetLevelCount(pDestinationTexture);
5395
5396         switch (sourceType) {
5397         case WINED3DRTYPE_TEXTURE:
5398             {
5399                 IWineD3DSurface *srcSurface;
5400                 IWineD3DSurface *destSurface;
5401
5402                 for (i = 0 ; i < levels ; ++i) {
5403                     IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pSourceTexture,      i, &srcSurface);
5404                     IWineD3DTexture_GetSurfaceLevel((IWineD3DTexture *)pDestinationTexture, i, &destSurface);
5405                     hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5406                     IWineD3DSurface_Release(srcSurface);
5407                     IWineD3DSurface_Release(destSurface);
5408                     if (WINED3D_OK != hr) {
5409                         WARN("(%p) : Call to update surface failed\n", This);
5410                         return hr;
5411                     }
5412                 }
5413             }
5414             break;
5415         case WINED3DRTYPE_CUBETEXTURE:
5416             {
5417                 IWineD3DSurface *srcSurface;
5418                 IWineD3DSurface *destSurface;
5419                 WINED3DCUBEMAP_FACES faceType;
5420
5421                 for (i = 0 ; i < levels ; ++i) {
5422                     /* Update each cube face */
5423                     for (faceType = WINED3DCUBEMAP_FACE_POSITIVE_X; faceType <= WINED3DCUBEMAP_FACE_NEGATIVE_Z; ++faceType){
5424                         hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pSourceTexture,      faceType, i, &srcSurface);
5425                         if (WINED3D_OK != hr) {
5426                             FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5427                         } else {
5428                             TRACE("Got srcSurface %p\n", srcSurface);
5429                         }
5430                         hr = IWineD3DCubeTexture_GetCubeMapSurface((IWineD3DCubeTexture *)pDestinationTexture, faceType, i, &destSurface);
5431                         if (WINED3D_OK != hr) {
5432                             FIXME("(%p) : Failed to get src cube surface facetype %d, level %d\n", This, faceType, i);
5433                         } else {
5434                             TRACE("Got desrSurface %p\n", destSurface);
5435                         }
5436                         hr = IWineD3DDevice_UpdateSurface(iface, srcSurface, NULL, destSurface, NULL);
5437                         IWineD3DSurface_Release(srcSurface);
5438                         IWineD3DSurface_Release(destSurface);
5439                         if (WINED3D_OK != hr) {
5440                             WARN("(%p) : Call to update surface failed\n", This);
5441                             return hr;
5442                         }
5443                     }
5444                 }
5445             }
5446             break;
5447
5448         case WINED3DRTYPE_VOLUMETEXTURE:
5449             {
5450                 IWineD3DVolume  *srcVolume  = NULL;
5451                 IWineD3DVolume  *destVolume = NULL;
5452
5453                 for (i = 0 ; i < levels ; ++i) {
5454                     IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)pSourceTexture,      i, &srcVolume);
5455                     IWineD3DVolumeTexture_GetVolumeLevel((IWineD3DVolumeTexture *)pDestinationTexture, i, &destVolume);
5456                     hr =  IWineD3DDeviceImpl_UpdateVolume(iface, srcVolume, destVolume);
5457                     IWineD3DVolume_Release(srcVolume);
5458                     IWineD3DVolume_Release(destVolume);
5459                     if (WINED3D_OK != hr) {
5460                         WARN("(%p) : Call to update volume failed\n", This);
5461                         return hr;
5462                     }
5463                 }
5464             }
5465             break;
5466
5467         default:
5468             FIXME("(%p) : Unsupported source and destination type\n", This);
5469             hr = WINED3DERR_INVALIDCALL;
5470         }
5471     }
5472
5473     return hr;
5474 }
5475
5476 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetFrontBufferData(IWineD3DDevice *iface,UINT iSwapChain, IWineD3DSurface *pDestSurface) {
5477     IWineD3DSwapChain *swapChain;
5478     HRESULT hr;
5479     hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
5480     if(hr == WINED3D_OK) {
5481         hr = IWineD3DSwapChain_GetFrontBufferData(swapChain, pDestSurface);
5482                 IWineD3DSwapChain_Release(swapChain);
5483     }
5484     return hr;
5485 }
5486
5487 static HRESULT  WINAPI  IWineD3DDeviceImpl_ValidateDevice(IWineD3DDevice *iface, DWORD* pNumPasses) {
5488     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5489     IWineD3DBaseTextureImpl *texture;
5490     const struct GlPixelFormatDesc *gl_info;
5491     DWORD i;
5492
5493     TRACE("(%p) : %p\n", This, pNumPasses);
5494
5495     for(i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
5496         if(This->stateBlock->samplerState[i][WINED3DSAMP_MINFILTER] == WINED3DTEXF_NONE) {
5497             WARN("Sampler state %u has minfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
5498             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
5499         }
5500         if(This->stateBlock->samplerState[i][WINED3DSAMP_MAGFILTER] == WINED3DTEXF_NONE) {
5501             WARN("Sampler state %u has magfilter D3DTEXF_NONE, returning D3DERR_UNSUPPORTEDTEXTUREFILTER\n", i);
5502             return WINED3DERR_UNSUPPORTEDTEXTUREFILTER;
5503         }
5504
5505         texture = (IWineD3DBaseTextureImpl *) This->stateBlock->textures[i];
5506         if(!texture) continue;
5507         getFormatDescEntry(texture->resource.format, &GLINFO_LOCATION, &gl_info);
5508         if(gl_info->Flags & WINED3DFMT_FLAG_FILTERING) continue;
5509
5510         if(This->stateBlock->samplerState[i][WINED3DSAMP_MAGFILTER] != WINED3DTEXF_POINT) {
5511             WARN("Non-filterable texture and mag filter enabled on samper %u, returning E_FAIL\n", i);
5512             return E_FAIL;
5513         }
5514         if(This->stateBlock->samplerState[i][WINED3DSAMP_MINFILTER] != WINED3DTEXF_POINT) {
5515             WARN("Non-filterable texture and min filter enabled on samper %u, returning E_FAIL\n", i);
5516             return E_FAIL;
5517         }
5518         if(This->stateBlock->samplerState[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_NONE &&
5519            This->stateBlock->samplerState[i][WINED3DSAMP_MIPFILTER] != WINED3DTEXF_POINT /* sic! */) {
5520             WARN("Non-filterable texture and mip filter enabled on samper %u, returning E_FAIL\n", i);
5521             return E_FAIL;
5522         }
5523     }
5524
5525     /* return a sensible default */
5526     *pNumPasses = 1;
5527
5528     TRACE("returning D3D_OK\n");
5529     return WINED3D_OK;
5530 }
5531
5532 static void dirtify_p8_texture_samplers(IWineD3DDeviceImpl *device)
5533 {
5534     int i;
5535
5536     for (i = 0; i < MAX_COMBINED_SAMPLERS; i++) {
5537             IWineD3DBaseTextureImpl *texture = (IWineD3DBaseTextureImpl*)device->stateBlock->textures[i];
5538             if (texture && (texture->resource.format == WINED3DFMT_P8 || texture->resource.format == WINED3DFMT_A8P8)) {
5539                 IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(i));
5540             }
5541         }
5542 }
5543
5544 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, CONST PALETTEENTRY* pEntries) {
5545     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5546     int j;
5547     UINT NewSize;
5548     PALETTEENTRY **palettes;
5549
5550     TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5551
5552     if (PaletteNumber >= MAX_PALETTES) {
5553         ERR("(%p) : (%u) Out of range 0-%u, returning Invalid Call\n", This, PaletteNumber, MAX_PALETTES);
5554         return WINED3DERR_INVALIDCALL;
5555     }
5556
5557     if (PaletteNumber >= This->NumberOfPalettes) {
5558         NewSize = This->NumberOfPalettes;
5559         do {
5560            NewSize *= 2;
5561         } while(PaletteNumber >= NewSize);
5562         palettes = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->palettes, sizeof(PALETTEENTRY*) * NewSize);
5563         if (!palettes) {
5564             ERR("Out of memory!\n");
5565             return E_OUTOFMEMORY;
5566         }
5567         This->palettes = palettes;
5568         This->NumberOfPalettes = NewSize;
5569     }
5570
5571     if (!This->palettes[PaletteNumber]) {
5572         This->palettes[PaletteNumber] = HeapAlloc(GetProcessHeap(),  0, sizeof(PALETTEENTRY) * 256);
5573         if (!This->palettes[PaletteNumber]) {
5574             ERR("Out of memory!\n");
5575             return E_OUTOFMEMORY;
5576         }
5577     }
5578
5579     for (j = 0; j < 256; ++j) {
5580         This->palettes[PaletteNumber][j].peRed   = pEntries[j].peRed;
5581         This->palettes[PaletteNumber][j].peGreen = pEntries[j].peGreen;
5582         This->palettes[PaletteNumber][j].peBlue  = pEntries[j].peBlue;
5583         This->palettes[PaletteNumber][j].peFlags = pEntries[j].peFlags;
5584     }
5585     if (PaletteNumber == This->currentPalette) dirtify_p8_texture_samplers(This);
5586     TRACE("(%p) : returning\n", This);
5587     return WINED3D_OK;
5588 }
5589
5590 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetPaletteEntries(IWineD3DDevice *iface, UINT PaletteNumber, PALETTEENTRY* pEntries) {
5591     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5592     int j;
5593     TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5594     if (PaletteNumber >= This->NumberOfPalettes || !This->palettes[PaletteNumber]) {
5595         /* What happens in such situation isn't documented; Native seems to silently abort
5596            on such conditions. Return Invalid Call. */
5597         ERR("(%p) : (%u) Nonexistent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5598         return WINED3DERR_INVALIDCALL;
5599     }
5600     for (j = 0; j < 256; ++j) {
5601         pEntries[j].peRed   = This->palettes[PaletteNumber][j].peRed;
5602         pEntries[j].peGreen = This->palettes[PaletteNumber][j].peGreen;
5603         pEntries[j].peBlue  = This->palettes[PaletteNumber][j].peBlue;
5604         pEntries[j].peFlags = This->palettes[PaletteNumber][j].peFlags;
5605     }
5606     TRACE("(%p) : returning\n", This);
5607     return WINED3D_OK;
5608 }
5609
5610 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetCurrentTexturePalette(IWineD3DDevice *iface, UINT PaletteNumber) {
5611     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5612     TRACE("(%p) : PaletteNumber %u\n", This, PaletteNumber);
5613     /* Native appears to silently abort on attempt to make an uninitialized palette current and render.
5614        (tested with reference rasterizer). Return Invalid Call. */
5615     if (PaletteNumber >= This->NumberOfPalettes || !This->palettes[PaletteNumber]) {
5616         ERR("(%p) : (%u) Nonexistent palette. NumberOfPalettes %u\n", This, PaletteNumber, This->NumberOfPalettes);
5617         return WINED3DERR_INVALIDCALL;
5618     }
5619     /*TODO: stateblocks */
5620     if (This->currentPalette != PaletteNumber) {
5621         This->currentPalette = PaletteNumber;
5622         dirtify_p8_texture_samplers(This);
5623     }
5624     TRACE("(%p) : returning\n", This);
5625     return WINED3D_OK;
5626 }
5627
5628 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetCurrentTexturePalette(IWineD3DDevice *iface, UINT* PaletteNumber) {
5629     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5630     if (PaletteNumber == NULL) {
5631         WARN("(%p) : returning Invalid Call\n", This);
5632         return WINED3DERR_INVALIDCALL;
5633     }
5634     /*TODO: stateblocks */
5635     *PaletteNumber = This->currentPalette;
5636     TRACE("(%p) : returning  %u\n", This, *PaletteNumber);
5637     return WINED3D_OK;
5638 }
5639
5640 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetSoftwareVertexProcessing(IWineD3DDevice *iface, BOOL bSoftware) {
5641     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5642     static BOOL warned;
5643     if (!warned)
5644     {
5645         FIXME("(%p) : stub\n", This);
5646         warned = TRUE;
5647     }
5648
5649     This->softwareVertexProcessing = bSoftware;
5650     return WINED3D_OK;
5651 }
5652
5653
5654 static BOOL     WINAPI  IWineD3DDeviceImpl_GetSoftwareVertexProcessing(IWineD3DDevice *iface) {
5655     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5656     static BOOL warned;
5657     if (!warned)
5658     {
5659         FIXME("(%p) : stub\n", This);
5660         warned = TRUE;
5661     }
5662     return This->softwareVertexProcessing;
5663 }
5664
5665
5666 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetRasterStatus(IWineD3DDevice *iface, UINT iSwapChain, WINED3DRASTER_STATUS* pRasterStatus) {
5667     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5668     IWineD3DSwapChain *swapChain;
5669     HRESULT hr;
5670
5671     TRACE("(%p) :  SwapChain %d returning %p\n", This, iSwapChain, pRasterStatus);
5672
5673     hr = IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapChain);
5674     if(hr == WINED3D_OK){
5675         hr = IWineD3DSwapChain_GetRasterStatus(swapChain, pRasterStatus);
5676         IWineD3DSwapChain_Release(swapChain);
5677     }else{
5678         FIXME("(%p) IWineD3DSwapChain_GetRasterStatus returned in error\n", This);
5679     }
5680     return hr;
5681 }
5682
5683
5684 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetNPatchMode(IWineD3DDevice *iface, float nSegments) {
5685     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5686     static BOOL warned;
5687     if(nSegments != 0.0f) {
5688         if (!warned)
5689         {
5690             FIXME("(%p) : stub nSegments(%f)\n", This, nSegments);
5691             warned = TRUE;
5692         }
5693     }
5694     return WINED3D_OK;
5695 }
5696
5697 static float    WINAPI  IWineD3DDeviceImpl_GetNPatchMode(IWineD3DDevice *iface) {
5698     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5699     static BOOL warned;
5700     if (!warned)
5701     {
5702         FIXME("(%p) : stub returning(%f)\n", This, 0.0f);
5703         warned = TRUE;
5704     }
5705     return 0.0f;
5706 }
5707
5708 static HRESULT  WINAPI  IWineD3DDeviceImpl_UpdateSurface(IWineD3DDevice *iface, IWineD3DSurface *pSourceSurface, CONST RECT* pSourceRect, IWineD3DSurface *pDestinationSurface, CONST POINT* pDestPoint) {
5709     IWineD3DDeviceImpl  *This         = (IWineD3DDeviceImpl *) iface;
5710     /** TODO: remove casts to IWineD3DSurfaceImpl
5711      *       NOTE: move code to surface to accomplish this
5712       ****************************************/
5713     IWineD3DSurfaceImpl *pSrcSurface  = (IWineD3DSurfaceImpl *)pSourceSurface;
5714     int srcWidth, srcHeight;
5715     unsigned int  srcSurfaceWidth, srcSurfaceHeight, destSurfaceWidth, destSurfaceHeight;
5716     WINED3DFORMAT destFormat, srcFormat;
5717     UINT          destSize;
5718     int srcLeft, destLeft, destTop;
5719     WINED3DPOOL       srcPool, destPool;
5720     int offset    = 0;
5721     int rowoffset = 0; /* how many bytes to add onto the end of a row to wraparound to the beginning of the next */
5722     glDescriptor *glDescription = NULL;
5723     GLenum dummy;
5724     int sampler;
5725     int bpp;
5726     CONVERT_TYPES convert = NO_CONVERSION;
5727
5728     WINED3DSURFACE_DESC  winedesc;
5729
5730     TRACE("(%p) : Source (%p)  Rect (%p) Destination (%p) Point(%p)\n", This, pSourceSurface, pSourceRect, pDestinationSurface, pDestPoint);
5731     memset(&winedesc, 0, sizeof(winedesc));
5732     winedesc.Width  = &srcSurfaceWidth;
5733     winedesc.Height = &srcSurfaceHeight;
5734     winedesc.Pool   = &srcPool;
5735     winedesc.Format = &srcFormat;
5736
5737     IWineD3DSurface_GetDesc(pSourceSurface, &winedesc);
5738
5739     winedesc.Width  = &destSurfaceWidth;
5740     winedesc.Height = &destSurfaceHeight;
5741     winedesc.Pool   = &destPool;
5742     winedesc.Format = &destFormat;
5743     winedesc.Size   = &destSize;
5744
5745     IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5746
5747     if(srcPool != WINED3DPOOL_SYSTEMMEM  || destPool != WINED3DPOOL_DEFAULT){
5748         WARN("source %p must be SYSTEMMEM and dest %p must be DEFAULT, returning WINED3DERR_INVALIDCALL\n", pSourceSurface, pDestinationSurface);
5749         return WINED3DERR_INVALIDCALL;
5750     }
5751
5752     /* This call loads the opengl surface directly, instead of copying the surface to the
5753      * destination's sysmem copy. If surface conversion is needed, use BltFast instead to
5754      * copy in sysmem and use regular surface loading.
5755      */
5756     d3dfmt_get_conv((IWineD3DSurfaceImpl *) pDestinationSurface, FALSE, TRUE,
5757                     &dummy, &dummy, &dummy, &convert, &bpp, FALSE);
5758     if(convert != NO_CONVERSION) {
5759         return IWineD3DSurface_BltFast(pDestinationSurface,
5760                                         pDestPoint  ? pDestPoint->x : 0,
5761                                         pDestPoint  ? pDestPoint->y : 0,
5762                                         pSourceSurface, pSourceRect, 0);
5763     }
5764
5765     if (destFormat == WINED3DFMT_UNKNOWN) {
5766         TRACE("(%p) : Converting destination surface from WINED3DFMT_UNKNOWN to the source format\n", This);
5767         IWineD3DSurface_SetFormat(pDestinationSurface, srcFormat);
5768
5769         /* Get the update surface description */
5770         IWineD3DSurface_GetDesc(pDestinationSurface, &winedesc);
5771     }
5772
5773     ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
5774
5775     ENTER_GL();
5776     GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
5777     checkGLcall("glActiveTextureARB");
5778     LEAVE_GL();
5779
5780     /* Make sure the surface is loaded and up to date */
5781     IWineD3DSurface_PreLoad(pDestinationSurface);
5782     IWineD3DSurface_BindTexture(pDestinationSurface);
5783
5784     IWineD3DSurface_GetGlDesc(pDestinationSurface, &glDescription);
5785
5786     /* this needs to be done in lines if the sourceRect != the sourceWidth */
5787     srcWidth   = pSourceRect ? pSourceRect->right - pSourceRect->left   : srcSurfaceWidth;
5788     srcHeight  = pSourceRect ? pSourceRect->bottom - pSourceRect->top   : srcSurfaceHeight;
5789     srcLeft    = pSourceRect ? pSourceRect->left : 0;
5790     destLeft   = pDestPoint  ? pDestPoint->x : 0;
5791     destTop    = pDestPoint  ? pDestPoint->y : 0;
5792
5793
5794     /* This function doesn't support compressed textures
5795     the pitch is just bytesPerPixel * width */
5796     if(srcWidth != srcSurfaceWidth  || srcLeft ){
5797         rowoffset = srcSurfaceWidth * pSrcSurface->bytesPerPixel;
5798         offset   += srcLeft * pSrcSurface->bytesPerPixel;
5799         /* TODO: do we ever get 3bpp?, would a shift and an add be quicker than a mul (well maybe a cycle or two) */
5800     }
5801     /* TODO DXT formats */
5802
5803     if(pSourceRect != NULL && pSourceRect->top != 0){
5804        offset +=  pSourceRect->top * srcSurfaceWidth * pSrcSurface->bytesPerPixel;
5805     }
5806     TRACE("(%p) glTexSubImage2D, level %d, left %d, top %d, width %d, height %d, fmt %#x, type %#x, memory %p+%#x\n",
5807             This, glDescription->level, destLeft, destTop, srcWidth, srcHeight, glDescription->glFormat,
5808             glDescription->glType, IWineD3DSurface_GetData(pSourceSurface), offset);
5809
5810     /* Sanity check */
5811     if (IWineD3DSurface_GetData(pSourceSurface) == NULL) {
5812
5813         /* need to lock the surface to get the data */
5814         FIXME("Surfaces has no allocated memory, but should be an in memory only surface\n");
5815     }
5816
5817     ENTER_GL();
5818
5819     /* TODO: Cube and volume support */
5820     if(rowoffset != 0){
5821         /* not a whole row so we have to do it a line at a time */
5822         int j;
5823
5824         /* hopefully using pointer addition will be quicker than using a point + j * rowoffset */
5825         const unsigned char* data =((const unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
5826
5827         for(j = destTop ; j < (srcHeight + destTop) ; j++){
5828
5829                 glTexSubImage2D(glDescription->target
5830                     ,glDescription->level
5831                     ,destLeft
5832                     ,j
5833                     ,srcWidth
5834                     ,1
5835                     ,glDescription->glFormat
5836                     ,glDescription->glType
5837                     ,data /* could be quicker using */
5838                 );
5839             data += rowoffset;
5840         }
5841
5842     } else { /* Full width, so just write out the whole texture */
5843         const unsigned char* data = ((const unsigned char *)IWineD3DSurface_GetData(pSourceSurface)) + offset;
5844
5845         if (WINED3DFMT_DXT1 == destFormat ||
5846             WINED3DFMT_DXT2 == destFormat ||
5847             WINED3DFMT_DXT3 == destFormat ||
5848             WINED3DFMT_DXT4 == destFormat ||
5849             WINED3DFMT_DXT5 == destFormat) {
5850             if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
5851                 if (destSurfaceHeight != srcHeight || destSurfaceWidth != srcWidth) {
5852                     /* FIXME: The easy way to do this is to lock the destination, and copy the bits across */
5853                     FIXME("Updating part of a compressed texture is not supported at the moment\n");
5854                 } if (destFormat != srcFormat) {
5855                     FIXME("Updating mixed format compressed texture is not curretly support\n");
5856                 } else {
5857                     GL_EXTCALL(glCompressedTexImage2DARB(glDescription->target, glDescription->level,
5858                             glDescription->glFormatInternal, srcWidth, srcHeight, 0, destSize, data));
5859                 }
5860             } else {
5861                 FIXME("Attempting to update a DXT compressed texture without hardware support\n");
5862             }
5863
5864
5865         } else {
5866             glTexSubImage2D(glDescription->target, glDescription->level, destLeft, destTop,
5867                     srcWidth, srcHeight, glDescription->glFormat, glDescription->glType, data);
5868         }
5869      }
5870     checkGLcall("glTexSubImage2D");
5871
5872     LEAVE_GL();
5873
5874     IWineD3DSurface_ModifyLocation(pDestinationSurface, SFLAG_INTEXTURE, TRUE);
5875     sampler = This->rev_tex_unit_map[0];
5876     if (sampler != -1) {
5877         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(sampler));
5878     }
5879
5880     return WINED3D_OK;
5881 }
5882
5883 static HRESULT WINAPI IWineD3DDeviceImpl_DrawRectPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DRECTPATCH_INFO* pRectPatchInfo) {
5884     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5885     struct WineD3DRectPatch *patch;
5886     unsigned int i;
5887     struct list *e;
5888     BOOL found;
5889     TRACE("(%p) Handle(%d) noSegs(%p) rectpatch(%p)\n", This, Handle, pNumSegs, pRectPatchInfo);
5890
5891     if(!(Handle || pRectPatchInfo)) {
5892         /* TODO: Write a test for the return value, thus the FIXME */
5893         FIXME("Both Handle and pRectPatchInfo are NULL\n");
5894         return WINED3DERR_INVALIDCALL;
5895     }
5896
5897     if(Handle) {
5898         i = PATCHMAP_HASHFUNC(Handle);
5899         found = FALSE;
5900         LIST_FOR_EACH(e, &This->patches[i]) {
5901             patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5902             if(patch->Handle == Handle) {
5903                 found = TRUE;
5904                 break;
5905             }
5906         }
5907
5908         if(!found) {
5909             TRACE("Patch does not exist. Creating a new one\n");
5910             patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5911             patch->Handle = Handle;
5912             list_add_head(&This->patches[i], &patch->entry);
5913         } else {
5914             TRACE("Found existing patch %p\n", patch);
5915         }
5916     } else {
5917         /* Since opengl does not load tesselated vertex attributes into numbered vertex
5918          * attributes we have to tesselate, read back, and draw. This needs a patch
5919          * management structure instance. Create one.
5920          *
5921          * A possible improvement is to check if a vertex shader is used, and if not directly
5922          * draw the patch.
5923          */
5924         FIXME("Drawing an uncached patch. This is slow\n");
5925         patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
5926     }
5927
5928     if(pNumSegs[0] != patch->numSegs[0] || pNumSegs[1] != patch->numSegs[1] ||
5929        pNumSegs[2] != patch->numSegs[2] || pNumSegs[3] != patch->numSegs[3] ||
5930        (pRectPatchInfo && memcmp(pRectPatchInfo, &patch->RectPatchInfo, sizeof(*pRectPatchInfo)) != 0) ) {
5931         HRESULT hr;
5932         TRACE("Tesselation density or patch info changed, retesselating\n");
5933
5934         if(pRectPatchInfo) {
5935             patch->RectPatchInfo = *pRectPatchInfo;
5936         }
5937         patch->numSegs[0] = pNumSegs[0];
5938         patch->numSegs[1] = pNumSegs[1];
5939         patch->numSegs[2] = pNumSegs[2];
5940         patch->numSegs[3] = pNumSegs[3];
5941
5942         hr = tesselate_rectpatch(This, patch);
5943         if(FAILED(hr)) {
5944             WARN("Patch tesselation failed\n");
5945
5946             /* Do not release the handle to store the params of the patch */
5947             if(!Handle) {
5948                 HeapFree(GetProcessHeap(), 0, patch);
5949             }
5950             return hr;
5951         }
5952     }
5953
5954     This->currentPatch = patch;
5955     IWineD3DDevice_DrawPrimitiveStrided(iface, WINED3DPT_TRIANGLELIST, patch->numSegs[0] * patch->numSegs[1] * 2, &patch->strided);
5956     This->currentPatch = NULL;
5957
5958     /* Destroy uncached patches */
5959     if(!Handle) {
5960         HeapFree(GetProcessHeap(), 0, patch->mem);
5961         HeapFree(GetProcessHeap(), 0, patch);
5962     }
5963     return WINED3D_OK;
5964 }
5965
5966 static HRESULT WINAPI IWineD3DDeviceImpl_DrawTriPatch(IWineD3DDevice *iface, UINT Handle, CONST float* pNumSegs, CONST WINED3DTRIPATCH_INFO* pTriPatchInfo) {
5967     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5968     TRACE("(%p) Handle(%d) noSegs(%p) tripatch(%p)\n", This, Handle, pNumSegs, pTriPatchInfo);
5969     FIXME("(%p) : Stub\n", This);
5970     return WINED3D_OK;
5971 }
5972
5973 static HRESULT WINAPI IWineD3DDeviceImpl_DeletePatch(IWineD3DDevice *iface, UINT Handle) {
5974     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
5975     int i;
5976     struct WineD3DRectPatch *patch;
5977     struct list *e;
5978     TRACE("(%p) Handle(%d)\n", This, Handle);
5979
5980     i = PATCHMAP_HASHFUNC(Handle);
5981     LIST_FOR_EACH(e, &This->patches[i]) {
5982         patch = LIST_ENTRY(e, struct WineD3DRectPatch, entry);
5983         if(patch->Handle == Handle) {
5984             TRACE("Deleting patch %p\n", patch);
5985             list_remove(&patch->entry);
5986             HeapFree(GetProcessHeap(), 0, patch->mem);
5987             HeapFree(GetProcessHeap(), 0, patch);
5988             return WINED3D_OK;
5989         }
5990     }
5991
5992     /* TODO: Write a test for the return value */
5993     FIXME("Attempt to destroy nonexistent patch\n");
5994     return WINED3DERR_INVALIDCALL;
5995 }
5996
5997 static IWineD3DSwapChain *get_swapchain(IWineD3DSurface *target) {
5998     HRESULT hr;
5999     IWineD3DSwapChain *swapchain;
6000
6001     hr = IWineD3DSurface_GetContainer(target, &IID_IWineD3DSwapChain, (void **)&swapchain);
6002     if (SUCCEEDED(hr)) {
6003         IWineD3DSwapChain_Release((IUnknown *)swapchain);
6004         return swapchain;
6005     }
6006
6007     return NULL;
6008 }
6009
6010 static void color_fill_fbo(IWineD3DDevice *iface, IWineD3DSurface *surface, CONST WINED3DRECT *rect, WINED3DCOLOR color) {
6011     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6012     IWineD3DSwapChain *swapchain;
6013
6014     swapchain = get_swapchain(surface);
6015     if (swapchain) {
6016         GLenum buffer;
6017
6018         TRACE("Surface %p is onscreen\n", surface);
6019
6020         ActivateContext(This, surface, CTXUSAGE_RESOURCELOAD);
6021         ENTER_GL();
6022         GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6023         buffer = surface_get_gl_buffer(surface, swapchain);
6024         glDrawBuffer(buffer);
6025         checkGLcall("glDrawBuffer()");
6026     } else {
6027         TRACE("Surface %p is offscreen\n", surface);
6028
6029         ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6030         ENTER_GL();
6031         context_bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->activeContext->dst_fbo);
6032         context_attach_surface_fbo(This, GL_FRAMEBUFFER_EXT, 0, surface);
6033         GL_EXTCALL(glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0));
6034         checkGLcall("glFramebufferRenderbufferEXT");
6035     }
6036
6037     if (rect) {
6038         glEnable(GL_SCISSOR_TEST);
6039         if(!swapchain) {
6040             glScissor(rect->x1, rect->y1, rect->x2 - rect->x1, rect->y2 - rect->y1);
6041         } else {
6042             glScissor(rect->x1, ((IWineD3DSurfaceImpl *)surface)->currentDesc.Height - rect->y2,
6043                     rect->x2 - rect->x1, rect->y2 - rect->y1);
6044         }
6045         checkGLcall("glScissor");
6046         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SCISSORRECT);
6047     } else {
6048         glDisable(GL_SCISSOR_TEST);
6049     }
6050     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
6051
6052     glDisable(GL_BLEND);
6053     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ALPHABLENDENABLE));
6054
6055     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
6056     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
6057
6058     glClearColor(D3DCOLOR_R(color), D3DCOLOR_G(color), D3DCOLOR_B(color), D3DCOLOR_A(color));
6059     glClear(GL_COLOR_BUFFER_BIT);
6060     checkGLcall("glClear");
6061
6062     if (This->activeContext->current_fbo) {
6063         context_bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->activeContext->current_fbo->id);
6064     } else {
6065         GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6066         checkGLcall("glBindFramebuffer()");
6067     }
6068
6069     if (swapchain && surface == ((IWineD3DSwapChainImpl *)swapchain)->frontBuffer
6070             && ((IWineD3DSwapChainImpl *)swapchain)->backBuffer) {
6071         glDrawBuffer(GL_BACK);
6072         checkGLcall("glDrawBuffer()");
6073     }
6074
6075     LEAVE_GL();
6076 }
6077
6078 static inline DWORD argb_to_fmt(DWORD color, WINED3DFORMAT destfmt) {
6079     unsigned int r, g, b, a;
6080     DWORD ret;
6081
6082     if(destfmt == WINED3DFMT_A8R8G8B8 || destfmt == WINED3DFMT_X8R8G8B8 ||
6083        destfmt == WINED3DFMT_R8G8B8)
6084         return color;
6085
6086     TRACE("Converting color %08x to format %s\n", color, debug_d3dformat(destfmt));
6087
6088     a = (color & 0xff000000) >> 24;
6089     r = (color & 0x00ff0000) >> 16;
6090     g = (color & 0x0000ff00) >>  8;
6091     b = (color & 0x000000ff) >>  0;
6092
6093     switch(destfmt)
6094     {
6095         case WINED3DFMT_R5G6B5:
6096             if(r == 0xff && g == 0xff && b == 0xff) return 0xffff;
6097             r = (r * 32) / 256;
6098             g = (g * 64) / 256;
6099             b = (b * 32) / 256;
6100             ret  = r << 11;
6101             ret |= g << 5;
6102             ret |= b;
6103             TRACE("Returning %08x\n", ret);
6104             return ret;
6105
6106         case WINED3DFMT_X1R5G5B5:
6107         case WINED3DFMT_A1R5G5B5:
6108             a = (a *  2) / 256;
6109             r = (r * 32) / 256;
6110             g = (g * 32) / 256;
6111             b = (b * 32) / 256;
6112             ret  = a << 15;
6113             ret |= r << 10;
6114             ret |= g <<  5;
6115             ret |= b <<  0;
6116             TRACE("Returning %08x\n", ret);
6117             return ret;
6118
6119         case WINED3DFMT_A8:
6120             TRACE("Returning %08x\n", a);
6121             return a;
6122
6123         case WINED3DFMT_X4R4G4B4:
6124         case WINED3DFMT_A4R4G4B4:
6125             a = (a * 16) / 256;
6126             r = (r * 16) / 256;
6127             g = (g * 16) / 256;
6128             b = (b * 16) / 256;
6129             ret  = a << 12;
6130             ret |= r <<  8;
6131             ret |= g <<  4;
6132             ret |= b <<  0;
6133             TRACE("Returning %08x\n", ret);
6134             return ret;
6135
6136         case WINED3DFMT_R3G3B2:
6137             r = (r * 8) / 256;
6138             g = (g * 8) / 256;
6139             b = (b * 4) / 256;
6140             ret  = r <<  5;
6141             ret |= g <<  2;
6142             ret |= b <<  0;
6143             TRACE("Returning %08x\n", ret);
6144             return ret;
6145
6146         case WINED3DFMT_X8B8G8R8:
6147         case WINED3DFMT_A8B8G8R8:
6148             ret  = a << 24;
6149             ret |= b << 16;
6150             ret |= g <<  8;
6151             ret |= r <<  0;
6152             TRACE("Returning %08x\n", ret);
6153             return ret;
6154
6155         case WINED3DFMT_A2R10G10B10:
6156             a = (a *    4) / 256;
6157             r = (r * 1024) / 256;
6158             g = (g * 1024) / 256;
6159             b = (b * 1024) / 256;
6160             ret  = a << 30;
6161             ret |= r << 20;
6162             ret |= g << 10;
6163             ret |= b <<  0;
6164             TRACE("Returning %08x\n", ret);
6165             return ret;
6166
6167         case WINED3DFMT_A2B10G10R10:
6168             a = (a *    4) / 256;
6169             r = (r * 1024) / 256;
6170             g = (g * 1024) / 256;
6171             b = (b * 1024) / 256;
6172             ret  = a << 30;
6173             ret |= b << 20;
6174             ret |= g << 10;
6175             ret |= r <<  0;
6176             TRACE("Returning %08x\n", ret);
6177             return ret;
6178
6179         default:
6180             FIXME("Add a COLORFILL conversion for format %s\n", debug_d3dformat(destfmt));
6181             return 0;
6182     }
6183 }
6184
6185 static HRESULT WINAPI IWineD3DDeviceImpl_ColorFill(IWineD3DDevice *iface, IWineD3DSurface *pSurface, CONST WINED3DRECT* pRect, WINED3DCOLOR color) {
6186     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6187     IWineD3DSurfaceImpl *surface = (IWineD3DSurfaceImpl *) pSurface;
6188     WINEDDBLTFX BltFx;
6189     TRACE("(%p) Colour fill Surface: %p rect: %p color: 0x%08x\n", This, pSurface, pRect, color);
6190
6191     if (surface->resource.pool != WINED3DPOOL_DEFAULT && surface->resource.pool != WINED3DPOOL_SYSTEMMEM) {
6192         FIXME("call to colorfill with non WINED3DPOOL_DEFAULT or WINED3DPOOL_SYSTEMMEM surface\n");
6193         return WINED3DERR_INVALIDCALL;
6194     }
6195
6196     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
6197         color_fill_fbo(iface, pSurface, pRect, color);
6198         return WINED3D_OK;
6199     } else {
6200         /* Just forward this to the DirectDraw blitting engine */
6201         memset(&BltFx, 0, sizeof(BltFx));
6202         BltFx.dwSize = sizeof(BltFx);
6203         BltFx.u5.dwFillColor = argb_to_fmt(color, surface->resource.format);
6204         return IWineD3DSurface_Blt(pSurface, (const RECT *)pRect, NULL, NULL,
6205                 WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_NONE);
6206     }
6207 }
6208
6209 /* rendertarget and depth stencil functions */
6210 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetRenderTarget(IWineD3DDevice* iface,DWORD RenderTargetIndex, IWineD3DSurface **ppRenderTarget) {
6211     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6212
6213     if (RenderTargetIndex >= GL_LIMITS(buffers)) {
6214         ERR("(%p) : Only %d render targets are supported.\n", This, GL_LIMITS(buffers));
6215         return WINED3DERR_INVALIDCALL;
6216     }
6217
6218     *ppRenderTarget = This->render_targets[RenderTargetIndex];
6219     TRACE("(%p) : RenderTarget %d Index returning %p\n", This, RenderTargetIndex, *ppRenderTarget);
6220     /* Note inc ref on returned surface */
6221     if(*ppRenderTarget != NULL)
6222         IWineD3DSurface_AddRef(*ppRenderTarget);
6223     return WINED3D_OK;
6224 }
6225
6226 static HRESULT WINAPI IWineD3DDeviceImpl_SetFrontBackBuffers(IWineD3DDevice *iface, IWineD3DSurface *Front, IWineD3DSurface *Back) {
6227     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6228     IWineD3DSurfaceImpl *FrontImpl = (IWineD3DSurfaceImpl *) Front;
6229     IWineD3DSurfaceImpl *BackImpl = (IWineD3DSurfaceImpl *) Back;
6230     IWineD3DSwapChainImpl *Swapchain;
6231     HRESULT hr;
6232
6233     TRACE("(%p)->(%p,%p)\n", This, FrontImpl, BackImpl);
6234
6235     hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &Swapchain);
6236     if(hr != WINED3D_OK) {
6237         ERR("Can't get the swapchain\n");
6238         return hr;
6239     }
6240
6241     /* Make sure to release the swapchain */
6242     IWineD3DSwapChain_Release((IWineD3DSwapChain *) Swapchain);
6243
6244     if(FrontImpl && !(FrontImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) ) {
6245         ERR("Trying to set a front buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
6246         return WINED3DERR_INVALIDCALL;
6247     }
6248     else if(BackImpl && !(BackImpl->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
6249         ERR("Trying to set a back buffer which doesn't have WINED3DUSAGE_RENDERTARGET usage\n");
6250         return WINED3DERR_INVALIDCALL;
6251     }
6252
6253     if(Swapchain->frontBuffer != Front) {
6254         TRACE("Changing the front buffer from %p to %p\n", Swapchain->frontBuffer, Front);
6255
6256         if(Swapchain->frontBuffer)
6257             IWineD3DSurface_SetContainer(Swapchain->frontBuffer, NULL);
6258         Swapchain->frontBuffer = Front;
6259
6260         if(Swapchain->frontBuffer) {
6261             IWineD3DSurface_SetContainer(Swapchain->frontBuffer, (IWineD3DBase *) Swapchain);
6262         }
6263     }
6264
6265     if(Back && !Swapchain->backBuffer) {
6266         /* We need memory for the back buffer array - only one back buffer this way */
6267         Swapchain->backBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DSurface *));
6268         if(!Swapchain->backBuffer) {
6269             ERR("Out of memory\n");
6270             return E_OUTOFMEMORY;
6271         }
6272     }
6273
6274     if(Swapchain->backBuffer[0] != Back) {
6275         TRACE("Changing the back buffer from %p to %p\n", Swapchain->backBuffer, Back);
6276
6277         /* What to do about the context here in the case of multithreading? Not sure.
6278          * This function is called by IDirect3D7::CreateDevice so in theory its initialization code
6279          */
6280         ENTER_GL();
6281         if(!Swapchain->backBuffer[0]) {
6282             /* GL was told to draw to the front buffer at creation,
6283              * undo that
6284              */
6285             glDrawBuffer(GL_BACK);
6286             checkGLcall("glDrawBuffer(GL_BACK)");
6287             /* Set the backbuffer count to 1 because other code uses it to fing the back buffers */
6288             Swapchain->presentParms.BackBufferCount = 1;
6289         } else if (!Back) {
6290             /* That makes problems - disable for now */
6291             /* glDrawBuffer(GL_FRONT); */
6292             checkGLcall("glDrawBuffer(GL_FRONT)");
6293             /* We have lost our back buffer, set this to 0 to avoid confusing other code */
6294             Swapchain->presentParms.BackBufferCount = 0;
6295         }
6296         LEAVE_GL();
6297
6298         if(Swapchain->backBuffer[0])
6299             IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], NULL);
6300         Swapchain->backBuffer[0] = Back;
6301
6302         if(Swapchain->backBuffer[0]) {
6303             IWineD3DSurface_SetContainer(Swapchain->backBuffer[0], (IWineD3DBase *) Swapchain);
6304         } else {
6305             HeapFree(GetProcessHeap(), 0, Swapchain->backBuffer);
6306             Swapchain->backBuffer = NULL;
6307         }
6308
6309     }
6310
6311     return WINED3D_OK;
6312 }
6313
6314 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetDepthStencilSurface(IWineD3DDevice* iface, IWineD3DSurface **ppZStencilSurface) {
6315     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6316     *ppZStencilSurface = This->stencilBufferTarget;
6317     TRACE("(%p) : zStencilSurface  returning %p\n", This,  *ppZStencilSurface);
6318
6319     if(*ppZStencilSurface != NULL) {
6320         /* Note inc ref on returned surface */
6321         IWineD3DSurface_AddRef(*ppZStencilSurface);
6322         return WINED3D_OK;
6323     } else {
6324         return WINED3DERR_NOTFOUND;
6325     }
6326 }
6327
6328 void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
6329         IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip)
6330 {
6331     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6332     GLbitfield mask = GL_COLOR_BUFFER_BIT; /* TODO: Support blitting depth/stencil surfaces */
6333     IWineD3DSwapChain *src_swapchain, *dst_swapchain;
6334     GLenum gl_filter;
6335     POINT offset = {0, 0};
6336
6337     TRACE("(%p) : src_surface %p, src_rect %p, dst_surface %p, dst_rect %p, filter %s (0x%08x), flip %u\n",
6338             This, src_surface, src_rect, dst_surface, dst_rect, debug_d3dtexturefiltertype(filter), filter, flip);
6339     TRACE("src_rect [%u, %u]->[%u, %u]\n", src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2);
6340     TRACE("dst_rect [%u, %u]->[%u, %u]\n", dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2);
6341
6342     switch (filter) {
6343         case WINED3DTEXF_LINEAR:
6344             gl_filter = GL_LINEAR;
6345             break;
6346
6347         default:
6348             FIXME("Unsupported filter mode %s (0x%08x)\n", debug_d3dtexturefiltertype(filter), filter);
6349         case WINED3DTEXF_NONE:
6350         case WINED3DTEXF_POINT:
6351             gl_filter = GL_NEAREST;
6352             break;
6353     }
6354
6355     /* Attach src surface to src fbo */
6356     src_swapchain = get_swapchain(src_surface);
6357     if (src_swapchain) {
6358         GLenum buffer = surface_get_gl_buffer(src_surface, src_swapchain);
6359
6360         TRACE("Source surface %p is onscreen\n", src_surface);
6361         ActivateContext(This, src_surface, CTXUSAGE_RESOURCELOAD);
6362         /* Make sure the drawable is up to date. In the offscreen case
6363          * attach_surface_fbo() implicitly takes care of this. */
6364         IWineD3DSurface_LoadLocation(src_surface, SFLAG_INDRAWABLE, NULL);
6365
6366         if(buffer == GL_FRONT) {
6367             RECT windowsize;
6368             UINT h;
6369             ClientToScreen(((IWineD3DSwapChainImpl *)src_swapchain)->win_handle, &offset);
6370             GetClientRect(((IWineD3DSwapChainImpl *)src_swapchain)->win_handle, &windowsize);
6371             h = windowsize.bottom - windowsize.top;
6372             src_rect->x1 -= offset.x; src_rect->x2 -=offset.x;
6373             src_rect->y1 =  offset.y + h - src_rect->y1;
6374             src_rect->y2 =  offset.y + h - src_rect->y2;
6375         } else {
6376             src_rect->y1 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y1;
6377             src_rect->y2 = ((IWineD3DSurfaceImpl *)src_surface)->currentDesc.Height - src_rect->y2;
6378         }
6379
6380         ENTER_GL();
6381         GL_EXTCALL(glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0));
6382         glReadBuffer(buffer);
6383         checkGLcall("glReadBuffer()");
6384     } else {
6385         TRACE("Source surface %p is offscreen\n", src_surface);
6386         ENTER_GL();
6387         context_bind_fbo(iface, GL_READ_FRAMEBUFFER_EXT, &This->activeContext->src_fbo);
6388         context_attach_surface_fbo(This, GL_READ_FRAMEBUFFER_EXT, 0, src_surface);
6389         glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
6390         checkGLcall("glReadBuffer()");
6391         GL_EXTCALL(glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0));
6392         checkGLcall("glFramebufferRenderbufferEXT");
6393     }
6394     LEAVE_GL();
6395
6396     /* Attach dst surface to dst fbo */
6397     dst_swapchain = get_swapchain(dst_surface);
6398     if (dst_swapchain) {
6399         GLenum buffer = surface_get_gl_buffer(dst_surface, dst_swapchain);
6400
6401         TRACE("Destination surface %p is onscreen\n", dst_surface);
6402         ActivateContext(This, dst_surface, CTXUSAGE_RESOURCELOAD);
6403         /* Make sure the drawable is up to date. In the offscreen case
6404          * attach_surface_fbo() implicitly takes care of this. */
6405         IWineD3DSurface_LoadLocation(dst_surface, SFLAG_INDRAWABLE, NULL);
6406
6407         if(buffer == GL_FRONT) {
6408             RECT windowsize;
6409             UINT h;
6410             ClientToScreen(((IWineD3DSwapChainImpl *)dst_swapchain)->win_handle, &offset);
6411             GetClientRect(((IWineD3DSwapChainImpl *)dst_swapchain)->win_handle, &windowsize);
6412             h = windowsize.bottom - windowsize.top;
6413             dst_rect->x1 -= offset.x; dst_rect->x2 -=offset.x;
6414             dst_rect->y1 =  offset.y + h - dst_rect->y1;
6415             dst_rect->y2 =  offset.y + h - dst_rect->y2;
6416         } else {
6417             /* Screen coords = window coords, surface height = window height */
6418             dst_rect->y1 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y1;
6419             dst_rect->y2 = ((IWineD3DSurfaceImpl *)dst_surface)->currentDesc.Height - dst_rect->y2;
6420         }
6421
6422         ENTER_GL();
6423         GL_EXTCALL(glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0));
6424         glDrawBuffer(buffer);
6425         checkGLcall("glDrawBuffer()");
6426     } else {
6427         TRACE("Destination surface %p is offscreen\n", dst_surface);
6428
6429         /* No src or dst swapchain? Make sure some context is active(multithreading) */
6430         if(!src_swapchain) {
6431             ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6432         }
6433
6434         ENTER_GL();
6435         context_bind_fbo(iface, GL_DRAW_FRAMEBUFFER_EXT, &This->activeContext->dst_fbo);
6436         context_attach_surface_fbo(This, GL_DRAW_FRAMEBUFFER_EXT, 0, dst_surface);
6437         glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
6438         checkGLcall("glDrawBuffer()");
6439         GL_EXTCALL(glFramebufferRenderbufferEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0));
6440         checkGLcall("glFramebufferRenderbufferEXT");
6441     }
6442     glDisable(GL_SCISSOR_TEST);
6443     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
6444
6445     if (flip) {
6446         GL_EXTCALL(glBlitFramebufferEXT(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
6447                 dst_rect->x1, dst_rect->y2, dst_rect->x2, dst_rect->y1, mask, gl_filter));
6448         checkGLcall("glBlitFramebuffer()");
6449     } else {
6450         GL_EXTCALL(glBlitFramebufferEXT(src_rect->x1, src_rect->y1, src_rect->x2, src_rect->y2,
6451                 dst_rect->x1, dst_rect->y1, dst_rect->x2, dst_rect->y2, mask, gl_filter));
6452         checkGLcall("glBlitFramebuffer()");
6453     }
6454
6455     IWineD3DSurface_ModifyLocation(dst_surface, SFLAG_INDRAWABLE, TRUE);
6456
6457     if (This->activeContext->current_fbo) {
6458         context_bind_fbo(iface, GL_FRAMEBUFFER_EXT, &This->activeContext->current_fbo->id);
6459     } else {
6460         GL_EXTCALL(glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0));
6461         checkGLcall("glBindFramebuffer()");
6462     }
6463
6464     /* If we switched from GL_BACK to GL_FRONT above, we need to switch back here */
6465     if (dst_swapchain && dst_surface == ((IWineD3DSwapChainImpl *)dst_swapchain)->frontBuffer
6466             && ((IWineD3DSwapChainImpl *)dst_swapchain)->backBuffer) {
6467         glDrawBuffer(GL_BACK);
6468         checkGLcall("glDrawBuffer()");
6469     }
6470     LEAVE_GL();
6471 }
6472
6473 static HRESULT WINAPI IWineD3DDeviceImpl_SetRenderTarget(IWineD3DDevice *iface, DWORD RenderTargetIndex, IWineD3DSurface *pRenderTarget) {
6474     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6475     WINED3DVIEWPORT viewport;
6476
6477     TRACE("(%p) : Setting rendertarget %d to %p\n", This, RenderTargetIndex, pRenderTarget);
6478
6479     if (RenderTargetIndex >= GL_LIMITS(buffers)) {
6480         WARN("(%p) : Unsupported target %u set, returning WINED3DERR_INVALIDCALL(only %u supported)\n",
6481              This, RenderTargetIndex, GL_LIMITS(buffers));
6482         return WINED3DERR_INVALIDCALL;
6483     }
6484
6485     /* MSDN says that null disables the render target
6486     but a device must always be associated with a render target
6487     nope MSDN says that we return invalid call to a null rendertarget with an index of 0
6488     */
6489     if (RenderTargetIndex == 0 && pRenderTarget == NULL) {
6490         FIXME("Trying to set render target 0 to NULL\n");
6491         return WINED3DERR_INVALIDCALL;
6492     }
6493     if (pRenderTarget && !(((IWineD3DSurfaceImpl *)pRenderTarget)->resource.usage & WINED3DUSAGE_RENDERTARGET)) {
6494         FIXME("(%p)Trying to set the render target to a surface(%p) that wasn't created with a usage of WINED3DUSAGE_RENDERTARGET\n",This ,pRenderTarget);
6495         return WINED3DERR_INVALIDCALL;
6496     }
6497
6498     /* If we are trying to set what we already have, don't bother */
6499     if (pRenderTarget == This->render_targets[RenderTargetIndex]) {
6500         TRACE("Trying to do a NOP SetRenderTarget operation\n");
6501         return WINED3D_OK;
6502     }
6503     if(pRenderTarget) IWineD3DSurface_AddRef(pRenderTarget);
6504     if(This->render_targets[RenderTargetIndex]) IWineD3DSurface_Release(This->render_targets[RenderTargetIndex]);
6505     This->render_targets[RenderTargetIndex] = pRenderTarget;
6506
6507     /* Render target 0 is special */
6508     if(RenderTargetIndex == 0) {
6509         /* Finally, reset the viewport as the MSDN states. */
6510         viewport.Height = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Height;
6511         viewport.Width  = ((IWineD3DSurfaceImpl *)This->render_targets[0])->currentDesc.Width;
6512         viewport.X      = 0;
6513         viewport.Y      = 0;
6514         viewport.MaxZ   = 1.0f;
6515         viewport.MinZ   = 0.0f;
6516         IWineD3DDeviceImpl_SetViewport(iface, &viewport);
6517         /* Make sure the viewport state is dirty, because the render_offscreen thing affects it.
6518          * SetViewport may catch NOP viewport changes, which would occur when switching between equally sized targets
6519          */
6520         IWineD3DDeviceImpl_MarkStateDirty(This, STATE_VIEWPORT);
6521     }
6522     return WINED3D_OK;
6523 }
6524
6525 static HRESULT WINAPI IWineD3DDeviceImpl_SetDepthStencilSurface(IWineD3DDevice *iface, IWineD3DSurface *pNewZStencil) {
6526     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
6527     HRESULT  hr = WINED3D_OK;
6528     IWineD3DSurface *tmp;
6529
6530     TRACE("(%p) Swapping z-buffer. Old = %p, new = %p\n",This, This->stencilBufferTarget, pNewZStencil);
6531
6532     if (pNewZStencil == This->stencilBufferTarget) {
6533         TRACE("Trying to do a NOP SetRenderTarget operation\n");
6534     } else {
6535         /** OpenGL doesn't support 'sharing' of the stencilBuffer so we may incur an extra memory overhead
6536         * depending on the renter target implementation being used.
6537         * A shared context implementation will share all buffers between all rendertargets (including swapchains),
6538         * implementations that use separate pbuffers for different swapchains or rendertargets will have to duplicate the
6539         * stencil buffer and incur an extra memory overhead
6540          ******************************************************/
6541
6542         if (This->stencilBufferTarget) {
6543             if (((IWineD3DSwapChainImpl *)This->swapchains[0])->presentParms.Flags & WINED3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
6544                     || ((IWineD3DSurfaceImpl *)This->stencilBufferTarget)->Flags & SFLAG_DISCARD) {
6545                 surface_modify_ds_location(This->stencilBufferTarget, SFLAG_DS_DISCARDED);
6546             } else {
6547                 ActivateContext(This, This->render_targets[0], CTXUSAGE_RESOURCELOAD);
6548                 surface_load_ds_location(This->stencilBufferTarget, SFLAG_DS_OFFSCREEN);
6549                 surface_modify_ds_location(This->stencilBufferTarget, SFLAG_DS_OFFSCREEN);
6550             }
6551         }
6552
6553         tmp = This->stencilBufferTarget;
6554         This->stencilBufferTarget = pNewZStencil;
6555         /* should we be calling the parent or the wined3d surface? */
6556         if (NULL != This->stencilBufferTarget) IWineD3DSurface_AddRef(This->stencilBufferTarget);
6557         if (NULL != tmp) IWineD3DSurface_Release(tmp);
6558         hr = WINED3D_OK;
6559
6560         if((!tmp && pNewZStencil) || (!pNewZStencil && tmp)) {
6561             /* Swapping NULL / non NULL depth stencil affects the depth and tests */
6562             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_ZENABLE));
6563             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILENABLE));
6564             IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
6565         }
6566     }
6567
6568     return hr;
6569 }
6570
6571 static HRESULT  WINAPI  IWineD3DDeviceImpl_SetCursorProperties(IWineD3DDevice* iface, UINT XHotSpot,
6572                                                         UINT YHotSpot, IWineD3DSurface *pCursorBitmap) {
6573     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6574     /* TODO: the use of Impl is deprecated. */
6575     IWineD3DSurfaceImpl * pSur = (IWineD3DSurfaceImpl *) pCursorBitmap;
6576     WINED3DLOCKED_RECT lockedRect;
6577
6578     TRACE("(%p) : Spot Pos(%u,%u)\n", This, XHotSpot, YHotSpot);
6579
6580     /* some basic validation checks */
6581     if(This->cursorTexture) {
6582         ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6583         ENTER_GL();
6584         glDeleteTextures(1, &This->cursorTexture);
6585         LEAVE_GL();
6586         This->cursorTexture = 0;
6587     }
6588
6589     if ( (pSur->currentDesc.Width == 32) && (pSur->currentDesc.Height == 32) )
6590         This->haveHardwareCursor = TRUE;
6591     else
6592         This->haveHardwareCursor = FALSE;
6593
6594     if(pCursorBitmap) {
6595         WINED3DLOCKED_RECT rect;
6596
6597         /* MSDN: Cursor must be A8R8G8B8 */
6598         if (WINED3DFMT_A8R8G8B8 != pSur->resource.format) {
6599             ERR("(%p) : surface(%p) has an invalid format\n", This, pCursorBitmap);
6600             return WINED3DERR_INVALIDCALL;
6601         }
6602
6603         /* MSDN: Cursor must be smaller than the display mode */
6604         if(pSur->currentDesc.Width > This->ddraw_width ||
6605            pSur->currentDesc.Height > This->ddraw_height) {
6606             ERR("(%p) : Surface(%p) is %dx%d pixels, but screen res is %dx%d\n", This, pSur, pSur->currentDesc.Width, pSur->currentDesc.Height, This->ddraw_width, This->ddraw_height);
6607             return WINED3DERR_INVALIDCALL;
6608         }
6609
6610         if (!This->haveHardwareCursor) {
6611             /* TODO: MSDN: Cursor sizes must be a power of 2 */
6612
6613             /* Do not store the surface's pointer because the application may
6614              * release it after setting the cursor image. Windows doesn't
6615              * addref the set surface, so we can't do this either without
6616              * creating circular refcount dependencies. Copy out the gl texture
6617              * instead.
6618              */
6619             This->cursorWidth = pSur->currentDesc.Width;
6620             This->cursorHeight = pSur->currentDesc.Height;
6621             if (SUCCEEDED(IWineD3DSurface_LockRect(pCursorBitmap, &rect, NULL, WINED3DLOCK_READONLY)))
6622             {
6623                 const struct GlPixelFormatDesc *glDesc;
6624                 const StaticPixelFormatDesc *tableEntry = getFormatDescEntry(WINED3DFMT_A8R8G8B8, &GLINFO_LOCATION, &glDesc);
6625                 char *mem, *bits = (char *)rect.pBits;
6626                 GLint intfmt = glDesc->glInternal;
6627                 GLint format = glDesc->glFormat;
6628                 GLint type = glDesc->glType;
6629                 INT height = This->cursorHeight;
6630                 INT width = This->cursorWidth;
6631                 INT bpp = tableEntry->bpp;
6632                 INT i, sampler;
6633
6634                 /* Reformat the texture memory (pitch and width can be
6635                  * different) */
6636                 mem = HeapAlloc(GetProcessHeap(), 0, width * height * bpp);
6637                 for(i = 0; i < height; i++)
6638                     memcpy(&mem[width * bpp * i], &bits[rect.Pitch * i], width * bpp);
6639                 IWineD3DSurface_UnlockRect(pCursorBitmap);
6640                 ENTER_GL();
6641
6642                 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
6643                     glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
6644                     checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
6645                 }
6646
6647                 /* Make sure that a proper texture unit is selected */
6648                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
6649                 checkGLcall("glActiveTextureARB");
6650                 sampler = This->rev_tex_unit_map[0];
6651                 if (sampler != -1) {
6652                     IWineD3DDeviceImpl_MarkStateDirty(This, STATE_SAMPLER(sampler));
6653                 }
6654                 /* Create a new cursor texture */
6655                 glGenTextures(1, &This->cursorTexture);
6656                 checkGLcall("glGenTextures");
6657                 glBindTexture(GL_TEXTURE_2D, This->cursorTexture);
6658                 checkGLcall("glBindTexture");
6659                 /* Copy the bitmap memory into the cursor texture */
6660                 glTexImage2D(GL_TEXTURE_2D, 0, intfmt, width, height, 0, format, type, mem);
6661                 HeapFree(GetProcessHeap(), 0, mem);
6662                 checkGLcall("glTexImage2D");
6663
6664                 if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
6665                     glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
6666                     checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
6667                 }
6668
6669                 LEAVE_GL();
6670             }
6671             else
6672             {
6673                 FIXME("A cursor texture was not returned.\n");
6674                 This->cursorTexture = 0;
6675             }
6676         }
6677         else
6678         {
6679             /* Draw a hardware cursor */
6680             ICONINFO cursorInfo;
6681             HCURSOR cursor;
6682             /* Create and clear maskBits because it is not needed for
6683              * 32-bit cursors.  32x32 bits split into 32-bit chunks == 32
6684              * chunks. */
6685             DWORD *maskBits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
6686                 (pSur->currentDesc.Width * pSur->currentDesc.Height / 8));
6687             IWineD3DSurface_LockRect(pCursorBitmap, &lockedRect, NULL,
6688                                          WINED3DLOCK_NO_DIRTY_UPDATE |
6689                                          WINED3DLOCK_READONLY
6690             );
6691             TRACE("width: %i height: %i\n", pSur->currentDesc.Width,
6692                   pSur->currentDesc.Height);
6693
6694             cursorInfo.fIcon = FALSE;
6695             cursorInfo.xHotspot = XHotSpot;
6696             cursorInfo.yHotspot = YHotSpot;
6697             cursorInfo.hbmMask = CreateBitmap(pSur->currentDesc.Width,
6698                                               pSur->currentDesc.Height, 1,
6699                                               1, &maskBits);
6700             cursorInfo.hbmColor = CreateBitmap(pSur->currentDesc.Width,
6701                                                pSur->currentDesc.Height, 1,
6702                                                32, lockedRect.pBits);
6703             IWineD3DSurface_UnlockRect(pCursorBitmap);
6704             /* Create our cursor and clean up. */
6705             cursor = CreateIconIndirect(&cursorInfo);
6706             SetCursor(cursor);
6707             if (cursorInfo.hbmMask) DeleteObject(cursorInfo.hbmMask);
6708             if (cursorInfo.hbmColor) DeleteObject(cursorInfo.hbmColor);
6709             if (This->hardwareCursor) DestroyCursor(This->hardwareCursor);
6710             This->hardwareCursor = cursor;
6711             HeapFree(GetProcessHeap(), 0, maskBits);
6712         }
6713     }
6714
6715     This->xHotSpot = XHotSpot;
6716     This->yHotSpot = YHotSpot;
6717     return WINED3D_OK;
6718 }
6719
6720 static void     WINAPI  IWineD3DDeviceImpl_SetCursorPosition(IWineD3DDevice* iface, int XScreenSpace, int YScreenSpace, DWORD Flags) {
6721     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6722     TRACE("(%p) : SetPos to (%u,%u)\n", This, XScreenSpace, YScreenSpace);
6723
6724     This->xScreenSpace = XScreenSpace;
6725     This->yScreenSpace = YScreenSpace;
6726
6727     return;
6728
6729 }
6730
6731 static BOOL     WINAPI  IWineD3DDeviceImpl_ShowCursor(IWineD3DDevice* iface, BOOL bShow) {
6732     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6733     BOOL oldVisible = This->bCursorVisible;
6734     POINT pt;
6735
6736     TRACE("(%p) : visible(%d)\n", This, bShow);
6737
6738     /*
6739      * When ShowCursor is first called it should make the cursor appear at the OS's last
6740      * known cursor position.  Because of this, some applications just repetitively call
6741      * ShowCursor in order to update the cursor's position.  This behavior is undocumented.
6742      */
6743     GetCursorPos(&pt);
6744     This->xScreenSpace = pt.x;
6745     This->yScreenSpace = pt.y;
6746
6747     if (This->haveHardwareCursor) {
6748         This->bCursorVisible = bShow;
6749         if (bShow)
6750             SetCursor(This->hardwareCursor);
6751         else
6752             SetCursor(NULL);
6753     }
6754     else
6755     {
6756         if (This->cursorTexture)
6757             This->bCursorVisible = bShow;
6758     }
6759
6760     return oldVisible;
6761 }
6762
6763 static HRESULT  WINAPI  IWineD3DDeviceImpl_TestCooperativeLevel(IWineD3DDevice* iface) {
6764     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6765     IWineD3DResourceImpl *resource;
6766     TRACE("(%p) : state (%u)\n", This, This->state);
6767
6768     /* TODO: Implement wrapping of the WndProc so that mimimize and maximize can be monitored and the states adjusted. */
6769     switch (This->state) {
6770     case WINED3D_OK:
6771         return WINED3D_OK;
6772     case WINED3DERR_DEVICELOST:
6773         {
6774             LIST_FOR_EACH_ENTRY(resource, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
6775                 if (resource->resource.pool == WINED3DPOOL_DEFAULT)
6776                     return WINED3DERR_DEVICENOTRESET;
6777             }
6778             return WINED3DERR_DEVICELOST;
6779         }
6780     case WINED3DERR_DRIVERINTERNALERROR:
6781         return WINED3DERR_DRIVERINTERNALERROR;
6782     }
6783
6784     /* Unknown state */
6785     return WINED3DERR_DRIVERINTERNALERROR;
6786 }
6787
6788
6789 static HRESULT  WINAPI  IWineD3DDeviceImpl_EvictManagedResources(IWineD3DDevice* iface) {
6790     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6791     /** FIXME: Resource tracking needs to be done,
6792     * The closes we can do to this is set the priorities of all managed textures low
6793     * and then reset them.
6794      ***********************************************************/
6795     FIXME("(%p) : stub\n", This);
6796     return WINED3D_OK;
6797 }
6798
6799 static void updateSurfaceDesc(IWineD3DSurfaceImpl *surface, const WINED3DPRESENT_PARAMETERS* pPresentationParameters)
6800 {
6801     IWineD3DDeviceImpl *This = surface->resource.wineD3DDevice; /* for GL_SUPPORT */
6802
6803     /* Reallocate proper memory for the front and back buffer and adjust their sizes */
6804     if(surface->Flags & SFLAG_DIBSECTION) {
6805         /* Release the DC */
6806         SelectObject(surface->hDC, surface->dib.holdbitmap);
6807         DeleteDC(surface->hDC);
6808         /* Release the DIB section */
6809         DeleteObject(surface->dib.DIBsection);
6810         surface->dib.bitmap_data = NULL;
6811         surface->resource.allocatedMemory = NULL;
6812         surface->Flags &= ~SFLAG_DIBSECTION;
6813     }
6814     surface->currentDesc.Width = pPresentationParameters->BackBufferWidth;
6815     surface->currentDesc.Height = pPresentationParameters->BackBufferHeight;
6816     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) || GL_SUPPORT(ARB_TEXTURE_RECTANGLE) ||
6817         GL_SUPPORT(WINE_NORMALIZED_TEXRECT)) {
6818         surface->pow2Width = pPresentationParameters->BackBufferWidth;
6819         surface->pow2Height = pPresentationParameters->BackBufferHeight;
6820     } else {
6821         surface->pow2Width = surface->pow2Height = 1;
6822         while (surface->pow2Width < pPresentationParameters->BackBufferWidth) surface->pow2Width <<= 1;
6823         while (surface->pow2Height < pPresentationParameters->BackBufferHeight) surface->pow2Height <<= 1;
6824     }
6825     surface->glRect.left = 0;
6826     surface->glRect.top = 0;
6827     surface->glRect.right = surface->pow2Width;
6828     surface->glRect.bottom = surface->pow2Height;
6829
6830     if(surface->glDescription.textureName) {
6831         ActivateContext(This, This->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
6832         ENTER_GL();
6833         glDeleteTextures(1, &surface->glDescription.textureName);
6834         LEAVE_GL();
6835         surface->glDescription.textureName = 0;
6836         surface->Flags &= ~SFLAG_CLIENT;
6837     }
6838     if(surface->pow2Width != pPresentationParameters->BackBufferWidth ||
6839        surface->pow2Height != pPresentationParameters->BackBufferHeight) {
6840         surface->Flags |= SFLAG_NONPOW2;
6841     } else  {
6842         surface->Flags &= ~SFLAG_NONPOW2;
6843     }
6844     HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
6845     surface->resource.allocatedMemory = NULL;
6846     surface->resource.heapMemory = NULL;
6847     surface->resource.size = IWineD3DSurface_GetPitch((IWineD3DSurface *) surface) * surface->pow2Width;
6848     /* INDRAWABLE is a sane place for implicit targets after the reset, INSYSMEM is more appropriate for depth stencils. */
6849     if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL) {
6850         IWineD3DSurface_ModifyLocation((IWineD3DSurface *) surface, SFLAG_INSYSMEM, TRUE);
6851     } else {
6852         IWineD3DSurface_ModifyLocation((IWineD3DSurface *) surface, SFLAG_INDRAWABLE, TRUE);
6853     }
6854 }
6855
6856 static HRESULT WINAPI reset_unload_resources(IWineD3DResource *resource, void *data) {
6857     TRACE("Unloading resource %p\n", resource);
6858     IWineD3DResource_UnLoad(resource);
6859     IWineD3DResource_Release(resource);
6860     return S_OK;
6861 }
6862
6863 static BOOL is_display_mode_supported(IWineD3DDeviceImpl *This, const WINED3DPRESENT_PARAMETERS *pp)
6864 {
6865     UINT i, count;
6866     WINED3DDISPLAYMODE m;
6867     HRESULT hr;
6868
6869     /* All Windowed modes are supported, as is leaving the current mode */
6870     if(pp->Windowed) return TRUE;
6871     if(!pp->BackBufferWidth) return TRUE;
6872     if(!pp->BackBufferHeight) return TRUE;
6873
6874     count = IWineD3D_GetAdapterModeCount(This->wineD3D, This->adapter->num, WINED3DFMT_UNKNOWN);
6875     for(i = 0; i < count; i++) {
6876         memset(&m, 0, sizeof(m));
6877         hr = IWineD3D_EnumAdapterModes(This->wineD3D, This->adapter->num, WINED3DFMT_UNKNOWN, i, &m);
6878         if(FAILED(hr)) {
6879             ERR("EnumAdapterModes failed\n");
6880         }
6881         if(m.Width == pp->BackBufferWidth && m.Height == pp->BackBufferHeight) {
6882             /* Mode found, it is supported */
6883             return TRUE;
6884         }
6885     }
6886     /* Mode not found -> not supported */
6887     return FALSE;
6888 }
6889
6890 void delete_opengl_contexts(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain_iface) {
6891     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6892     IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) swapchain_iface;
6893     UINT i;
6894     IWineD3DBaseShaderImpl *shader;
6895
6896     IWineD3DDevice_EnumResources(iface, reset_unload_resources, NULL);
6897     LIST_FOR_EACH_ENTRY(shader, &This->shaders, IWineD3DBaseShaderImpl, baseShader.shader_list_entry) {
6898         This->shader_backend->shader_destroy((IWineD3DBaseShader *) shader);
6899     }
6900
6901     ENTER_GL();
6902     if(This->depth_blt_texture) {
6903         glDeleteTextures(1, &This->depth_blt_texture);
6904         This->depth_blt_texture = 0;
6905     }
6906     if (This->depth_blt_rb) {
6907         GL_EXTCALL(glDeleteRenderbuffersEXT(1, &This->depth_blt_rb));
6908         This->depth_blt_rb = 0;
6909         This->depth_blt_rb_w = 0;
6910         This->depth_blt_rb_h = 0;
6911     }
6912     LEAVE_GL();
6913
6914     This->blitter->free_private(iface);
6915     This->frag_pipe->free_private(iface);
6916     This->shader_backend->shader_free_private(iface);
6917
6918     ENTER_GL();
6919     for (i = 0; i < GL_LIMITS(textures); i++) {
6920         /* Textures are recreated below */
6921         glDeleteTextures(1, &This->dummyTextureName[i]);
6922         checkGLcall("glDeleteTextures(1, &This->dummyTextureName[i])");
6923         This->dummyTextureName[i] = 0;
6924     }
6925     LEAVE_GL();
6926
6927     while(This->numContexts) {
6928         DestroyContext(This, This->contexts[0]);
6929     }
6930     This->activeContext = NULL;
6931     HeapFree(GetProcessHeap(), 0, swapchain->context);
6932     swapchain->context = NULL;
6933     swapchain->num_contexts = 0;
6934 }
6935
6936 HRESULT create_primary_opengl_context(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain_iface) {
6937     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6938     IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) swapchain_iface;
6939     HRESULT hr;
6940     IWineD3DSurfaceImpl *target;
6941
6942     /* Recreate the primary swapchain's context */
6943     swapchain->context = HeapAlloc(GetProcessHeap(), 0, sizeof(*swapchain->context));
6944     if(swapchain->backBuffer) {
6945         target = (IWineD3DSurfaceImpl *) swapchain->backBuffer[0];
6946     } else {
6947         target = (IWineD3DSurfaceImpl *) swapchain->frontBuffer;
6948     }
6949     swapchain->context[0] = CreateContext(This, target, swapchain->win_handle, FALSE,
6950                                           &swapchain->presentParms);
6951     swapchain->num_contexts = 1;
6952     This->activeContext = swapchain->context[0];
6953
6954     create_dummy_textures(This);
6955
6956     hr = This->shader_backend->shader_alloc_private(iface);
6957     if(FAILED(hr)) {
6958         ERR("Failed to recreate shader private data\n");
6959         goto err_out;
6960     }
6961     hr = This->frag_pipe->alloc_private(iface);
6962     if(FAILED(hr)) {
6963         TRACE("Fragment pipeline private data couldn't be allocated\n");
6964         goto err_out;
6965     }
6966     hr = This->blitter->alloc_private(iface);
6967     if(FAILED(hr)) {
6968         TRACE("Blitter private data couldn't be allocated\n");
6969         goto err_out;
6970     }
6971
6972     return WINED3D_OK;
6973
6974 err_out:
6975     This->blitter->free_private(iface);
6976     This->frag_pipe->free_private(iface);
6977     This->shader_backend->shader_free_private(iface);
6978     return hr;
6979 }
6980
6981 static HRESULT WINAPI IWineD3DDeviceImpl_Reset(IWineD3DDevice* iface, WINED3DPRESENT_PARAMETERS* pPresentationParameters) {
6982     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
6983     IWineD3DSwapChainImpl *swapchain;
6984     HRESULT hr;
6985     BOOL DisplayModeChanged = FALSE;
6986     WINED3DDISPLAYMODE mode;
6987     TRACE("(%p)\n", This);
6988
6989     hr = IWineD3DDevice_GetSwapChain(iface, 0, (IWineD3DSwapChain **) &swapchain);
6990     if(FAILED(hr)) {
6991         ERR("Failed to get the first implicit swapchain\n");
6992         return hr;
6993     }
6994
6995     if(!is_display_mode_supported(This, pPresentationParameters)) {
6996         WARN("Rejecting Reset() call because the requested display mode is not supported\n");
6997         WARN("Requested mode: %d, %d\n", pPresentationParameters->BackBufferWidth,
6998              pPresentationParameters->BackBufferHeight);
6999         return WINED3DERR_INVALIDCALL;
7000     }
7001
7002     /* Is it necessary to recreate the gl context? Actually every setting can be changed
7003      * on an existing gl context, so there's no real need for recreation.
7004      *
7005      * TODO: Figure out how Reset influences resources in D3DPOOL_DEFAULT, D3DPOOL_SYSTEMMEMORY and D3DPOOL_MANAGED
7006      *
7007      * TODO: Figure out what happens to explicit swapchains, or if we have more than one implicit swapchain
7008      */
7009     TRACE("New params:\n");
7010     TRACE("BackBufferWidth = %d\n", pPresentationParameters->BackBufferWidth);
7011     TRACE("BackBufferHeight = %d\n", pPresentationParameters->BackBufferHeight);
7012     TRACE("BackBufferFormat = %s\n", debug_d3dformat(pPresentationParameters->BackBufferFormat));
7013     TRACE("BackBufferCount = %d\n", pPresentationParameters->BackBufferCount);
7014     TRACE("MultiSampleType = %d\n", pPresentationParameters->MultiSampleType);
7015     TRACE("MultiSampleQuality = %d\n", pPresentationParameters->MultiSampleQuality);
7016     TRACE("SwapEffect = %d\n", pPresentationParameters->SwapEffect);
7017     TRACE("hDeviceWindow = %p\n", pPresentationParameters->hDeviceWindow);
7018     TRACE("Windowed = %s\n", pPresentationParameters->Windowed ? "true" : "false");
7019     TRACE("EnableAutoDepthStencil = %s\n", pPresentationParameters->EnableAutoDepthStencil ? "true" : "false");
7020     TRACE("Flags = %08x\n", pPresentationParameters->Flags);
7021     TRACE("FullScreen_RefreshRateInHz = %d\n", pPresentationParameters->FullScreen_RefreshRateInHz);
7022     TRACE("PresentationInterval = %d\n", pPresentationParameters->PresentationInterval);
7023
7024     /* No special treatment of these parameters. Just store them */
7025     swapchain->presentParms.SwapEffect = pPresentationParameters->SwapEffect;
7026     swapchain->presentParms.Flags = pPresentationParameters->Flags;
7027     swapchain->presentParms.PresentationInterval = pPresentationParameters->PresentationInterval;
7028     swapchain->presentParms.FullScreen_RefreshRateInHz = pPresentationParameters->FullScreen_RefreshRateInHz;
7029
7030     /* What to do about these? */
7031     if(pPresentationParameters->BackBufferCount != 0 &&
7032         pPresentationParameters->BackBufferCount != swapchain->presentParms.BackBufferCount) {
7033         ERR("Cannot change the back buffer count yet\n");
7034     }
7035     if(pPresentationParameters->BackBufferFormat != WINED3DFMT_UNKNOWN &&
7036         pPresentationParameters->BackBufferFormat != swapchain->presentParms.BackBufferFormat) {
7037         ERR("Cannot change the back buffer format yet\n");
7038     }
7039     if(pPresentationParameters->hDeviceWindow != NULL &&
7040         pPresentationParameters->hDeviceWindow != swapchain->presentParms.hDeviceWindow) {
7041         ERR("Cannot change the device window yet\n");
7042     }
7043     if (pPresentationParameters->EnableAutoDepthStencil && !This->auto_depth_stencil_buffer) {
7044         WARN("Auto depth stencil enabled, but no auto depth stencil present, returning WINED3DERR_INVALIDCALL\n");
7045         return WINED3DERR_INVALIDCALL;
7046     }
7047
7048     /* Reset the depth stencil */
7049     if (pPresentationParameters->EnableAutoDepthStencil)
7050         IWineD3DDevice_SetDepthStencilSurface(iface, This->auto_depth_stencil_buffer);
7051     else
7052         IWineD3DDevice_SetDepthStencilSurface(iface, NULL);
7053
7054     delete_opengl_contexts(iface, (IWineD3DSwapChain *) swapchain);
7055
7056     if(pPresentationParameters->Windowed) {
7057         mode.Width = swapchain->orig_width;
7058         mode.Height = swapchain->orig_height;
7059         mode.RefreshRate = 0;
7060         mode.Format = swapchain->presentParms.BackBufferFormat;
7061     } else {
7062         mode.Width = pPresentationParameters->BackBufferWidth;
7063         mode.Height = pPresentationParameters->BackBufferHeight;
7064         mode.RefreshRate = pPresentationParameters->FullScreen_RefreshRateInHz;
7065         mode.Format = swapchain->presentParms.BackBufferFormat;
7066     }
7067
7068     /* Should Width == 800 && Height == 0 set 800x600? */
7069     if(pPresentationParameters->BackBufferWidth != 0 && pPresentationParameters->BackBufferHeight != 0 &&
7070        (pPresentationParameters->BackBufferWidth != swapchain->presentParms.BackBufferWidth ||
7071         pPresentationParameters->BackBufferHeight != swapchain->presentParms.BackBufferHeight))
7072     {
7073         UINT i;
7074
7075         if(!pPresentationParameters->Windowed) {
7076             DisplayModeChanged = TRUE;
7077         }
7078         swapchain->presentParms.BackBufferWidth = pPresentationParameters->BackBufferWidth;
7079         swapchain->presentParms.BackBufferHeight = pPresentationParameters->BackBufferHeight;
7080
7081         updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->frontBuffer, pPresentationParameters);
7082         for(i = 0; i < swapchain->presentParms.BackBufferCount; i++) {
7083             updateSurfaceDesc((IWineD3DSurfaceImpl *)swapchain->backBuffer[i], pPresentationParameters);
7084         }
7085         if(This->auto_depth_stencil_buffer) {
7086             updateSurfaceDesc((IWineD3DSurfaceImpl *)This->auto_depth_stencil_buffer, pPresentationParameters);
7087         }
7088     }
7089
7090     if((pPresentationParameters->Windowed && !swapchain->presentParms.Windowed) ||
7091        (swapchain->presentParms.Windowed && !pPresentationParameters->Windowed) ||
7092         DisplayModeChanged) {
7093
7094         IWineD3DDevice_SetDisplayMode(iface, 0, &mode);
7095
7096         if(swapchain->win_handle && !pPresentationParameters->Windowed) {
7097             if(swapchain->presentParms.Windowed) {
7098                 /* switch from windowed to fs */
7099                 IWineD3DDeviceImpl_SetupFullscreenWindow(iface, swapchain->win_handle,
7100                                                          pPresentationParameters->BackBufferWidth,
7101                                                          pPresentationParameters->BackBufferHeight);
7102             } else {
7103                 /* Fullscreen -> fullscreen mode change */
7104                 MoveWindow(swapchain->win_handle, 0, 0,
7105                            pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight,
7106                            TRUE);
7107             }
7108         } else if(swapchain->win_handle && !swapchain->presentParms.Windowed) {
7109             /* Fullscreen -> windowed switch */
7110             IWineD3DDeviceImpl_RestoreWindow(iface, swapchain->win_handle);
7111         }
7112         swapchain->presentParms.Windowed = pPresentationParameters->Windowed;
7113     } else if(!pPresentationParameters->Windowed) {
7114         DWORD style = This->style, exStyle = This->exStyle;
7115         /* If we're in fullscreen, and the mode wasn't changed, we have to get the window back into
7116          * the right position. Some applications(Battlefield 2, Guild Wars) move it and then call
7117          * Reset to clear up their mess. Guild Wars also loses the device during that.
7118          */
7119         This->style = 0;
7120         This->exStyle = 0;
7121         IWineD3DDeviceImpl_SetupFullscreenWindow(iface, swapchain->win_handle,
7122                                                  pPresentationParameters->BackBufferWidth,
7123                                                  pPresentationParameters->BackBufferHeight);
7124         This->style = style;
7125         This->exStyle = exStyle;
7126     }
7127
7128     TRACE("Resetting stateblock\n");
7129     IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->updateStateBlock);
7130     IWineD3DStateBlock_Release((IWineD3DStateBlock *)This->stateBlock);
7131
7132     /* Note: No parent needed for initial internal stateblock */
7133     hr = IWineD3DDevice_CreateStateBlock(iface, WINED3DSBT_INIT, (IWineD3DStateBlock **)&This->stateBlock, NULL);
7134     if (FAILED(hr)) ERR("Resetting the stateblock failed with error 0x%08x\n", hr);
7135     else TRACE("Created stateblock %p\n", This->stateBlock);
7136     This->updateStateBlock = This->stateBlock;
7137     IWineD3DStateBlock_AddRef((IWineD3DStateBlock *)This->updateStateBlock);
7138
7139     hr = IWineD3DStateBlock_InitStartupStateBlock((IWineD3DStateBlock *) This->stateBlock);
7140     if(FAILED(hr)) {
7141         ERR("Resetting the stateblock failed with error 0x%08x\n", hr);
7142     }
7143
7144     hr = create_primary_opengl_context(iface, (IWineD3DSwapChain *) swapchain);
7145     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
7146
7147     /* All done. There is no need to reload resources or shaders, this will happen automatically on the
7148      * first use
7149      */
7150     return hr;
7151 }
7152
7153 static HRESULT WINAPI IWineD3DDeviceImpl_SetDialogBoxMode(IWineD3DDevice *iface, BOOL bEnableDialogs) {
7154     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7155     /** FIXME: always true at the moment **/
7156     if(!bEnableDialogs) {
7157         FIXME("(%p) Dialogs cannot be disabled yet\n", This);
7158     }
7159     return WINED3D_OK;
7160 }
7161
7162
7163 static HRESULT  WINAPI  IWineD3DDeviceImpl_GetCreationParameters(IWineD3DDevice *iface, WINED3DDEVICE_CREATION_PARAMETERS *pParameters) {
7164     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7165     TRACE("(%p) : pParameters %p\n", This, pParameters);
7166
7167     *pParameters = This->createParms;
7168     return WINED3D_OK;
7169 }
7170
7171 static void WINAPI IWineD3DDeviceImpl_SetGammaRamp(IWineD3DDevice * iface, UINT iSwapChain, DWORD Flags, CONST WINED3DGAMMARAMP* pRamp) {
7172     IWineD3DSwapChain *swapchain;
7173
7174     TRACE("Relaying  to swapchain\n");
7175
7176     if (IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain) == WINED3D_OK) {
7177         IWineD3DSwapChain_SetGammaRamp(swapchain, Flags, pRamp);
7178         IWineD3DSwapChain_Release(swapchain);
7179     }
7180     return;
7181 }
7182
7183 static void WINAPI IWineD3DDeviceImpl_GetGammaRamp(IWineD3DDevice *iface, UINT iSwapChain, WINED3DGAMMARAMP* pRamp) {
7184     IWineD3DSwapChain *swapchain;
7185
7186     TRACE("Relaying  to swapchain\n");
7187
7188     if (IWineD3DDeviceImpl_GetSwapChain(iface, iSwapChain, &swapchain) == WINED3D_OK) {
7189         IWineD3DSwapChain_GetGammaRamp(swapchain, pRamp);
7190         IWineD3DSwapChain_Release(swapchain);
7191     }
7192     return;
7193 }
7194
7195
7196 /** ********************************************************
7197 *   Notification functions
7198 ** ********************************************************/
7199 /** This function must be called in the release of a resource when ref == 0,
7200 * the contents of resource must still be correct,
7201 * any handles to other resource held by the caller must be closed
7202 * (e.g. a texture should release all held surfaces because telling the device that it's been released.)
7203  *****************************************************/
7204 static void IWineD3DDeviceImpl_AddResource(IWineD3DDevice *iface, IWineD3DResource *resource){
7205     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7206
7207     TRACE("(%p) : Adding Resource %p\n", This, resource);
7208     list_add_head(&This->resources, &((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
7209 }
7210
7211 static void IWineD3DDeviceImpl_RemoveResource(IWineD3DDevice *iface, IWineD3DResource *resource){
7212     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
7213
7214     TRACE("(%p) : Removing resource %p\n", This, resource);
7215
7216     list_remove(&((IWineD3DResourceImpl *) resource)->resource.resource_list_entry);
7217 }
7218
7219
7220 static void WINAPI IWineD3DDeviceImpl_ResourceReleased(IWineD3DDevice *iface, IWineD3DResource *resource){
7221     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7222     WINED3DRESOURCETYPE type = IWineD3DResource_GetType(resource);
7223     int counter;
7224
7225     TRACE("(%p) : resource %p\n", This, resource);
7226
7227     context_resource_released(iface, resource, type);
7228
7229     switch (type) {
7230         /* TODO: check front and back buffers, rendertargets etc..  possibly swapchains? */
7231         case WINED3DRTYPE_SURFACE: {
7232             unsigned int i;
7233
7234             /* Cleanup any FBO attachments if d3d is enabled */
7235             if(This->d3d_initialized) {
7236                 if((IWineD3DSurface *)resource == This->lastActiveRenderTarget) {
7237                     IWineD3DSwapChainImpl *swapchain = This->swapchains ? (IWineD3DSwapChainImpl *) This->swapchains[0] : NULL;
7238
7239                     TRACE("Last active render target destroyed\n");
7240                     /* Find a replacement surface for the currently active back buffer. The context manager does not do NULL
7241                      * checks, so switch to a valid target as long as the currently set surface is still valid. Use the
7242                      * surface of the implicit swpchain. If that is the same as the destroyed surface the device is destroyed
7243                      * and the lastActiveRenderTarget member shouldn't matter
7244                      */
7245                     if(swapchain) {
7246                         if(swapchain->backBuffer && swapchain->backBuffer[0] != (IWineD3DSurface *)resource) {
7247                             TRACE("Activating primary back buffer\n");
7248                             ActivateContext(This, swapchain->backBuffer[0], CTXUSAGE_RESOURCELOAD);
7249                         } else if(!swapchain->backBuffer && swapchain->frontBuffer != (IWineD3DSurface *)resource) {
7250                             /* Single buffering environment */
7251                             TRACE("Activating primary front buffer\n");
7252                             ActivateContext(This, swapchain->frontBuffer, CTXUSAGE_RESOURCELOAD);
7253                         } else {
7254                             TRACE("Device is being destroyed, setting lastActiveRenderTarget = 0xdeadbabe\n");
7255                             /* Implicit render target destroyed, that means the device is being destroyed
7256                              * whatever we set here, it shouldn't matter
7257                              */
7258                             This->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadbabe;
7259                         }
7260                     } else {
7261                         /* May happen during ddraw uninitialization */
7262                         TRACE("Render target set, but swapchain does not exist!\n");
7263                         This->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadcafe;
7264                     }
7265                 }
7266
7267                 for (i = 0; i < GL_LIMITS(buffers); ++i) {
7268                     if (This->render_targets[i] == (IWineD3DSurface *)resource) {
7269                         This->render_targets[i] = NULL;
7270                     }
7271                 }
7272                 if (This->stencilBufferTarget == (IWineD3DSurface *)resource) {
7273                     This->stencilBufferTarget = NULL;
7274                 }
7275             }
7276
7277             break;
7278         }
7279         case WINED3DRTYPE_TEXTURE:
7280         case WINED3DRTYPE_CUBETEXTURE:
7281         case WINED3DRTYPE_VOLUMETEXTURE:
7282                 for (counter = 0; counter < MAX_COMBINED_SAMPLERS; counter++) {
7283                     if (This->stateBlock != NULL && This->stateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
7284                         WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
7285                         This->stateBlock->textures[counter] = NULL;
7286                     }
7287                     if (This->updateStateBlock != This->stateBlock ){
7288                         if (This->updateStateBlock->textures[counter] == (IWineD3DBaseTexture *)resource) {
7289                             WARN("Texture being released is still by a stateblock, Stage = %u Texture = %p\n", counter, resource);
7290                             This->updateStateBlock->textures[counter] = NULL;
7291                         }
7292                     }
7293                 }
7294         break;
7295         case WINED3DRTYPE_VOLUME:
7296         /* TODO: nothing really? */
7297         break;
7298         case WINED3DRTYPE_VERTEXBUFFER:
7299         /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed. */
7300         {
7301             int streamNumber;
7302             TRACE("Cleaning up stream pointers\n");
7303
7304             for(streamNumber = 0; streamNumber < MAX_STREAMS; streamNumber ++){
7305                 /* FINDOUT: should a warn be generated if were recording and updateStateBlock->streamSource is lost?
7306                 FINDOUT: should changes.streamSource[StreamNumber] be set ?
7307                 */
7308                 if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
7309                     if ((IWineD3DResource *)This->updateStateBlock->streamSource[streamNumber] == resource) {
7310                         FIXME("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
7311                         This->updateStateBlock->streamSource[streamNumber] = 0;
7312                         /* Set changed flag? */
7313                     }
7314                 }
7315                 if (This->stateBlock != NULL ) { /* only happens if there is an error in the application, or on reset/release (because we don't manage internal tracking properly) */
7316                     if ((IWineD3DResource *)This->stateBlock->streamSource[streamNumber] == resource) {
7317                         TRACE("Vertex buffer released while bound to a state block, stream %d\n", streamNumber);
7318                         This->stateBlock->streamSource[streamNumber] = 0;
7319                     }
7320                 }
7321             }
7322         }
7323         break;
7324         case WINED3DRTYPE_INDEXBUFFER:
7325         /* MSDN: When an application no longer holds a references to this interface, the interface will automatically be freed.*/
7326         if (This->updateStateBlock != NULL ) { /* ==NULL when device is being destroyed */
7327             if (This->updateStateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
7328                 This->updateStateBlock->pIndexData =  NULL;
7329             }
7330         }
7331         if (This->stateBlock != NULL ) { /* ==NULL when device is being destroyed */
7332             if (This->stateBlock->pIndexData == (IWineD3DIndexBuffer *)resource) {
7333                 This->stateBlock->pIndexData =  NULL;
7334             }
7335         }
7336
7337         break;
7338         default:
7339         FIXME("(%p) unknown resource type %p %u\n", This, resource, IWineD3DResource_GetType(resource));
7340         break;
7341     }
7342
7343
7344     /* Remove the resource from the resourceStore */
7345     IWineD3DDeviceImpl_RemoveResource(iface, resource);
7346
7347     TRACE("Resource released\n");
7348
7349 }
7350
7351 static HRESULT WINAPI IWineD3DDeviceImpl_EnumResources(IWineD3DDevice *iface, D3DCB_ENUMRESOURCES pCallback, void *pData) {
7352     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
7353     IWineD3DResourceImpl *resource, *cursor;
7354     HRESULT ret;
7355     TRACE("(%p)->(%p,%p)\n", This, pCallback, pData);
7356
7357     LIST_FOR_EACH_ENTRY_SAFE(resource, cursor, &This->resources, IWineD3DResourceImpl, resource.resource_list_entry) {
7358         TRACE("enumerating resource %p\n", resource);
7359         IWineD3DResource_AddRef((IWineD3DResource *) resource);
7360         ret = pCallback((IWineD3DResource *) resource, pData);
7361         if(ret == S_FALSE) {
7362             TRACE("Canceling enumeration\n");
7363             break;
7364         }
7365     }
7366     return WINED3D_OK;
7367 }
7368
7369 /**********************************************************
7370  * IWineD3DDevice VTbl follows
7371  **********************************************************/
7372
7373 const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl =
7374 {
7375     /*** IUnknown methods ***/
7376     IWineD3DDeviceImpl_QueryInterface,
7377     IWineD3DDeviceImpl_AddRef,
7378     IWineD3DDeviceImpl_Release,
7379     /*** IWineD3DDevice methods ***/
7380     IWineD3DDeviceImpl_GetParent,
7381     /*** Creation methods**/
7382     IWineD3DDeviceImpl_CreateVertexBuffer,
7383     IWineD3DDeviceImpl_CreateIndexBuffer,
7384     IWineD3DDeviceImpl_CreateStateBlock,
7385     IWineD3DDeviceImpl_CreateSurface,
7386     IWineD3DDeviceImpl_CreateTexture,
7387     IWineD3DDeviceImpl_CreateVolumeTexture,
7388     IWineD3DDeviceImpl_CreateVolume,
7389     IWineD3DDeviceImpl_CreateCubeTexture,
7390     IWineD3DDeviceImpl_CreateQuery,
7391     IWineD3DDeviceImpl_CreateSwapChain,
7392     IWineD3DDeviceImpl_CreateVertexDeclaration,
7393     IWineD3DDeviceImpl_CreateVertexDeclarationFromFVF,
7394     IWineD3DDeviceImpl_CreateVertexShader,
7395     IWineD3DDeviceImpl_CreatePixelShader,
7396     IWineD3DDeviceImpl_CreatePalette,
7397     /*** Odd functions **/
7398     IWineD3DDeviceImpl_Init3D,
7399     IWineD3DDeviceImpl_InitGDI,
7400     IWineD3DDeviceImpl_Uninit3D,
7401     IWineD3DDeviceImpl_UninitGDI,
7402     IWineD3DDeviceImpl_SetMultithreaded,
7403     IWineD3DDeviceImpl_EvictManagedResources,
7404     IWineD3DDeviceImpl_GetAvailableTextureMem,
7405     IWineD3DDeviceImpl_GetBackBuffer,
7406     IWineD3DDeviceImpl_GetCreationParameters,
7407     IWineD3DDeviceImpl_GetDeviceCaps,
7408     IWineD3DDeviceImpl_GetDirect3D,
7409     IWineD3DDeviceImpl_GetDisplayMode,
7410     IWineD3DDeviceImpl_SetDisplayMode,
7411     IWineD3DDeviceImpl_GetNumberOfSwapChains,
7412     IWineD3DDeviceImpl_GetRasterStatus,
7413     IWineD3DDeviceImpl_GetSwapChain,
7414     IWineD3DDeviceImpl_Reset,
7415     IWineD3DDeviceImpl_SetDialogBoxMode,
7416     IWineD3DDeviceImpl_SetCursorProperties,
7417     IWineD3DDeviceImpl_SetCursorPosition,
7418     IWineD3DDeviceImpl_ShowCursor,
7419     IWineD3DDeviceImpl_TestCooperativeLevel,
7420     /*** Getters and setters **/
7421     IWineD3DDeviceImpl_SetClipPlane,
7422     IWineD3DDeviceImpl_GetClipPlane,
7423     IWineD3DDeviceImpl_SetClipStatus,
7424     IWineD3DDeviceImpl_GetClipStatus,
7425     IWineD3DDeviceImpl_SetCurrentTexturePalette,
7426     IWineD3DDeviceImpl_GetCurrentTexturePalette,
7427     IWineD3DDeviceImpl_SetDepthStencilSurface,
7428     IWineD3DDeviceImpl_GetDepthStencilSurface,
7429     IWineD3DDeviceImpl_SetGammaRamp,
7430     IWineD3DDeviceImpl_GetGammaRamp,
7431     IWineD3DDeviceImpl_SetIndices,
7432     IWineD3DDeviceImpl_GetIndices,
7433     IWineD3DDeviceImpl_SetBaseVertexIndex,
7434     IWineD3DDeviceImpl_GetBaseVertexIndex,
7435     IWineD3DDeviceImpl_SetLight,
7436     IWineD3DDeviceImpl_GetLight,
7437     IWineD3DDeviceImpl_SetLightEnable,
7438     IWineD3DDeviceImpl_GetLightEnable,
7439     IWineD3DDeviceImpl_SetMaterial,
7440     IWineD3DDeviceImpl_GetMaterial,
7441     IWineD3DDeviceImpl_SetNPatchMode,
7442     IWineD3DDeviceImpl_GetNPatchMode,
7443     IWineD3DDeviceImpl_SetPaletteEntries,
7444     IWineD3DDeviceImpl_GetPaletteEntries,
7445     IWineD3DDeviceImpl_SetPixelShader,
7446     IWineD3DDeviceImpl_GetPixelShader,
7447     IWineD3DDeviceImpl_SetPixelShaderConstantB,
7448     IWineD3DDeviceImpl_GetPixelShaderConstantB,
7449     IWineD3DDeviceImpl_SetPixelShaderConstantI,
7450     IWineD3DDeviceImpl_GetPixelShaderConstantI,
7451     IWineD3DDeviceImpl_SetPixelShaderConstantF,
7452     IWineD3DDeviceImpl_GetPixelShaderConstantF,
7453     IWineD3DDeviceImpl_SetRenderState,
7454     IWineD3DDeviceImpl_GetRenderState,
7455     IWineD3DDeviceImpl_SetRenderTarget,
7456     IWineD3DDeviceImpl_GetRenderTarget,
7457     IWineD3DDeviceImpl_SetFrontBackBuffers,
7458     IWineD3DDeviceImpl_SetSamplerState,
7459     IWineD3DDeviceImpl_GetSamplerState,
7460     IWineD3DDeviceImpl_SetScissorRect,
7461     IWineD3DDeviceImpl_GetScissorRect,
7462     IWineD3DDeviceImpl_SetSoftwareVertexProcessing,
7463     IWineD3DDeviceImpl_GetSoftwareVertexProcessing,
7464     IWineD3DDeviceImpl_SetStreamSource,
7465     IWineD3DDeviceImpl_GetStreamSource,
7466     IWineD3DDeviceImpl_SetStreamSourceFreq,
7467     IWineD3DDeviceImpl_GetStreamSourceFreq,
7468     IWineD3DDeviceImpl_SetTexture,
7469     IWineD3DDeviceImpl_GetTexture,
7470     IWineD3DDeviceImpl_SetTextureStageState,
7471     IWineD3DDeviceImpl_GetTextureStageState,
7472     IWineD3DDeviceImpl_SetTransform,
7473     IWineD3DDeviceImpl_GetTransform,
7474     IWineD3DDeviceImpl_SetVertexDeclaration,
7475     IWineD3DDeviceImpl_GetVertexDeclaration,
7476     IWineD3DDeviceImpl_SetVertexShader,
7477     IWineD3DDeviceImpl_GetVertexShader,
7478     IWineD3DDeviceImpl_SetVertexShaderConstantB,
7479     IWineD3DDeviceImpl_GetVertexShaderConstantB,
7480     IWineD3DDeviceImpl_SetVertexShaderConstantI,
7481     IWineD3DDeviceImpl_GetVertexShaderConstantI,
7482     IWineD3DDeviceImpl_SetVertexShaderConstantF,
7483     IWineD3DDeviceImpl_GetVertexShaderConstantF,
7484     IWineD3DDeviceImpl_SetViewport,
7485     IWineD3DDeviceImpl_GetViewport,
7486     IWineD3DDeviceImpl_MultiplyTransform,
7487     IWineD3DDeviceImpl_ValidateDevice,
7488     IWineD3DDeviceImpl_ProcessVertices,
7489     /*** State block ***/
7490     IWineD3DDeviceImpl_BeginStateBlock,
7491     IWineD3DDeviceImpl_EndStateBlock,
7492     /*** Scene management ***/
7493     IWineD3DDeviceImpl_BeginScene,
7494     IWineD3DDeviceImpl_EndScene,
7495     IWineD3DDeviceImpl_Present,
7496     IWineD3DDeviceImpl_Clear,
7497     /*** Drawing ***/
7498     IWineD3DDeviceImpl_DrawPrimitive,
7499     IWineD3DDeviceImpl_DrawIndexedPrimitive,
7500     IWineD3DDeviceImpl_DrawPrimitiveUP,
7501     IWineD3DDeviceImpl_DrawIndexedPrimitiveUP,
7502     IWineD3DDeviceImpl_DrawPrimitiveStrided,
7503     IWineD3DDeviceImpl_DrawIndexedPrimitiveStrided,
7504     IWineD3DDeviceImpl_DrawRectPatch,
7505     IWineD3DDeviceImpl_DrawTriPatch,
7506     IWineD3DDeviceImpl_DeletePatch,
7507     IWineD3DDeviceImpl_ColorFill,
7508     IWineD3DDeviceImpl_UpdateTexture,
7509     IWineD3DDeviceImpl_UpdateSurface,
7510     IWineD3DDeviceImpl_GetFrontBufferData,
7511     /*** object tracking ***/
7512     IWineD3DDeviceImpl_ResourceReleased,
7513     IWineD3DDeviceImpl_EnumResources
7514 };
7515
7516 const DWORD SavedPixelStates_R[NUM_SAVEDPIXELSTATES_R] = {
7517     WINED3DRS_ALPHABLENDENABLE   ,
7518     WINED3DRS_ALPHAFUNC          ,
7519     WINED3DRS_ALPHAREF           ,
7520     WINED3DRS_ALPHATESTENABLE    ,
7521     WINED3DRS_BLENDOP            ,
7522     WINED3DRS_COLORWRITEENABLE   ,
7523     WINED3DRS_DESTBLEND          ,
7524     WINED3DRS_DITHERENABLE       ,
7525     WINED3DRS_FILLMODE           ,
7526     WINED3DRS_FOGDENSITY         ,
7527     WINED3DRS_FOGEND             ,
7528     WINED3DRS_FOGSTART           ,
7529     WINED3DRS_LASTPIXEL          ,
7530     WINED3DRS_SHADEMODE          ,
7531     WINED3DRS_SRCBLEND           ,
7532     WINED3DRS_STENCILENABLE      ,
7533     WINED3DRS_STENCILFAIL        ,
7534     WINED3DRS_STENCILFUNC        ,
7535     WINED3DRS_STENCILMASK        ,
7536     WINED3DRS_STENCILPASS        ,
7537     WINED3DRS_STENCILREF         ,
7538     WINED3DRS_STENCILWRITEMASK   ,
7539     WINED3DRS_STENCILZFAIL       ,
7540     WINED3DRS_TEXTUREFACTOR      ,
7541     WINED3DRS_WRAP0              ,
7542     WINED3DRS_WRAP1              ,
7543     WINED3DRS_WRAP2              ,
7544     WINED3DRS_WRAP3              ,
7545     WINED3DRS_WRAP4              ,
7546     WINED3DRS_WRAP5              ,
7547     WINED3DRS_WRAP6              ,
7548     WINED3DRS_WRAP7              ,
7549     WINED3DRS_ZENABLE            ,
7550     WINED3DRS_ZFUNC              ,
7551     WINED3DRS_ZWRITEENABLE
7552 };
7553
7554 const DWORD SavedPixelStates_T[NUM_SAVEDPIXELSTATES_T] = {
7555     WINED3DTSS_ADDRESSW              ,
7556     WINED3DTSS_ALPHAARG0             ,
7557     WINED3DTSS_ALPHAARG1             ,
7558     WINED3DTSS_ALPHAARG2             ,
7559     WINED3DTSS_ALPHAOP               ,
7560     WINED3DTSS_BUMPENVLOFFSET        ,
7561     WINED3DTSS_BUMPENVLSCALE         ,
7562     WINED3DTSS_BUMPENVMAT00          ,
7563     WINED3DTSS_BUMPENVMAT01          ,
7564     WINED3DTSS_BUMPENVMAT10          ,
7565     WINED3DTSS_BUMPENVMAT11          ,
7566     WINED3DTSS_COLORARG0             ,
7567     WINED3DTSS_COLORARG1             ,
7568     WINED3DTSS_COLORARG2             ,
7569     WINED3DTSS_COLOROP               ,
7570     WINED3DTSS_RESULTARG             ,
7571     WINED3DTSS_TEXCOORDINDEX         ,
7572     WINED3DTSS_TEXTURETRANSFORMFLAGS
7573 };
7574
7575 const DWORD SavedPixelStates_S[NUM_SAVEDPIXELSTATES_S] = {
7576     WINED3DSAMP_ADDRESSU         ,
7577     WINED3DSAMP_ADDRESSV         ,
7578     WINED3DSAMP_ADDRESSW         ,
7579     WINED3DSAMP_BORDERCOLOR      ,
7580     WINED3DSAMP_MAGFILTER        ,
7581     WINED3DSAMP_MINFILTER        ,
7582     WINED3DSAMP_MIPFILTER        ,
7583     WINED3DSAMP_MIPMAPLODBIAS    ,
7584     WINED3DSAMP_MAXMIPLEVEL      ,
7585     WINED3DSAMP_MAXANISOTROPY    ,
7586     WINED3DSAMP_SRGBTEXTURE      ,
7587     WINED3DSAMP_ELEMENTINDEX
7588 };
7589
7590 const DWORD SavedVertexStates_R[NUM_SAVEDVERTEXSTATES_R] = {
7591     WINED3DRS_AMBIENT                       ,
7592     WINED3DRS_AMBIENTMATERIALSOURCE         ,
7593     WINED3DRS_CLIPPING                      ,
7594     WINED3DRS_CLIPPLANEENABLE               ,
7595     WINED3DRS_COLORVERTEX                   ,
7596     WINED3DRS_DIFFUSEMATERIALSOURCE         ,
7597     WINED3DRS_EMISSIVEMATERIALSOURCE        ,
7598     WINED3DRS_FOGDENSITY                    ,
7599     WINED3DRS_FOGEND                        ,
7600     WINED3DRS_FOGSTART                      ,
7601     WINED3DRS_FOGTABLEMODE                  ,
7602     WINED3DRS_FOGVERTEXMODE                 ,
7603     WINED3DRS_INDEXEDVERTEXBLENDENABLE      ,
7604     WINED3DRS_LIGHTING                      ,
7605     WINED3DRS_LOCALVIEWER                   ,
7606     WINED3DRS_MULTISAMPLEANTIALIAS          ,
7607     WINED3DRS_MULTISAMPLEMASK               ,
7608     WINED3DRS_NORMALIZENORMALS              ,
7609     WINED3DRS_PATCHEDGESTYLE                ,
7610     WINED3DRS_POINTSCALE_A                  ,
7611     WINED3DRS_POINTSCALE_B                  ,
7612     WINED3DRS_POINTSCALE_C                  ,
7613     WINED3DRS_POINTSCALEENABLE              ,
7614     WINED3DRS_POINTSIZE                     ,
7615     WINED3DRS_POINTSIZE_MAX                 ,
7616     WINED3DRS_POINTSIZE_MIN                 ,
7617     WINED3DRS_POINTSPRITEENABLE             ,
7618     WINED3DRS_RANGEFOGENABLE                ,
7619     WINED3DRS_SPECULARMATERIALSOURCE        ,
7620     WINED3DRS_TWEENFACTOR                   ,
7621     WINED3DRS_VERTEXBLEND                   ,
7622     WINED3DRS_CULLMODE                      ,
7623     WINED3DRS_FOGCOLOR
7624 };
7625
7626 const DWORD SavedVertexStates_T[NUM_SAVEDVERTEXSTATES_T] = {
7627     WINED3DTSS_TEXCOORDINDEX         ,
7628     WINED3DTSS_TEXTURETRANSFORMFLAGS
7629 };
7630
7631 const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S] = {
7632     WINED3DSAMP_DMAPOFFSET
7633 };
7634
7635 void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state) {
7636     DWORD rep = This->StateTable[state].representative;
7637     DWORD idx;
7638     BYTE shift;
7639     UINT i;
7640     WineD3DContext *context;
7641
7642     if(!rep) return;
7643     for(i = 0; i < This->numContexts; i++) {
7644         context = This->contexts[i];
7645         if(isStateDirty(context, rep)) continue;
7646
7647         context->dirtyArray[context->numDirtyEntries++] = rep;
7648         idx = rep >> 5;
7649         shift = rep & 0x1f;
7650         context->isStateDirty[idx] |= (1 << shift);
7651     }
7652 }
7653
7654 void get_drawable_size_pbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7655     IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
7656     /* The drawable size of a pbuffer render target is the current pbuffer size
7657      */
7658     *width = dev->pbufferWidth;
7659     *height = dev->pbufferHeight;
7660 }
7661
7662 void get_drawable_size_fbo(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7663     /* The drawable size of a fbo target is the opengl texture size, which is the power of two size
7664      */
7665     *width = This->pow2Width;
7666     *height = This->pow2Height;
7667 }
7668
7669 void get_drawable_size_backbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height) {
7670     IWineD3DDeviceImpl *dev = This->resource.wineD3DDevice;
7671     /* The drawable size of a backbuffer / aux buffer offscreen target is the size of the
7672      * current context's drawable, which is the size of the back buffer of the swapchain
7673      * the active context belongs to. The back buffer of the swapchain is stored as the
7674      * surface the context belongs to.
7675      */
7676     *width = ((IWineD3DSurfaceImpl *) dev->activeContext->surface)->currentDesc.Width;
7677     *height = ((IWineD3DSurfaceImpl *) dev->activeContext->surface)->currentDesc.Height;
7678 }