dlls/d3d11/state.c

   1 /*
   2  * Copyright 2009 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include "d3d11_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  26
  27 /* ID3D11BlendState methods */
  28
  29 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_QueryInterface(ID3D11BlendState *iface,
  30         REFIID riid, void **object)
  31 {
  32     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
  33
  34     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  35
  36     if (IsEqualGUID(riid, &IID_ID3D11BlendState)
  37             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
  38             || IsEqualGUID(riid, &IID_IUnknown))
  39     {
  40         ID3D11BlendState_AddRef(iface);
  41         *object = iface;
  42         return S_OK;
  43     }
  44
  45     if (IsEqualGUID(riid, &IID_ID3D10BlendState1)
  46             || IsEqualGUID(riid, &IID_ID3D10BlendState)
  47             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
  48     {
  49         ID3D10BlendState1_AddRef(&state->ID3D10BlendState1_iface);
  50         *object = &state->ID3D10BlendState1_iface;
  51         return S_OK;
  52     }
  53
  54     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  55
  56     *object = NULL;
  57     return E_NOINTERFACE;
  58 }
  59
  60 static ULONG STDMETHODCALLTYPE d3d11_blend_state_AddRef(ID3D11BlendState *iface)
  61 {
  62     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
  63     ULONG refcount = InterlockedIncrement(&state->refcount);
  64
  65     TRACE("%p increasing refcount to %u.\n", state, refcount);
  66
  67     if (refcount == 1)
  68     {
  69         ID3D11Device_AddRef(state->device);
  70         wined3d_mutex_lock();
  71         wined3d_blend_state_incref(state->wined3d_state);
  72         wined3d_mutex_unlock();
  73     }
  74
  75     return refcount;
  76 }
  77
  78 static ULONG STDMETHODCALLTYPE d3d11_blend_state_Release(ID3D11BlendState *iface)
  79 {
  80     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
  81     ULONG refcount = InterlockedDecrement(&state->refcount);
  82
  83     TRACE("%p decreasing refcount to %u.\n", state, refcount);
  84
  85     if (!refcount)
  86     {
  87         ID3D11Device *device = state->device;
  88
  89         wined3d_mutex_lock();
  90         wined3d_blend_state_decref(state->wined3d_state);
  91         wined3d_mutex_unlock();
  92
  93         ID3D11Device_Release(device);
  94     }
  95
  96     return refcount;
  97 }
  98
  99 static void STDMETHODCALLTYPE d3d11_blend_state_GetDevice(ID3D11BlendState *iface,
 100         ID3D11Device **device)
 101 {
 102     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 103
 104     TRACE("iface %p, device %p.\n", iface, device);
 105
 106     *device = state->device;
 107     ID3D11Device_AddRef(*device);
 108 }
 109
 110 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_GetPrivateData(ID3D11BlendState *iface,
 111         REFGUID guid, UINT *data_size, void *data)
 112 {
 113     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 114
 115     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 116
 117     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 118 }
 119
 120 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_SetPrivateData(ID3D11BlendState *iface,
 121         REFGUID guid, UINT data_size, const void *data)
 122 {
 123     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 124
 125     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 126
 127     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 128 }
 129
 130 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_SetPrivateDataInterface(ID3D11BlendState *iface,
 131         REFGUID guid, const IUnknown *data)
 132 {
 133     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 134
 135     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 136
 137     return d3d_set_private_data_interface(&state->private_store, guid, data);
 138 }
 139
 140 static void STDMETHODCALLTYPE d3d11_blend_state_GetDesc(ID3D11BlendState *iface, D3D11_BLEND_DESC *desc)
 141 {
 142     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 143
 144     TRACE("iface %p, desc %p.\n", iface, desc);
 145
 146     *desc = state->desc;
 147 }
 148
 149 static const struct ID3D11BlendStateVtbl d3d11_blend_state_vtbl =
 150 {
 151     /* IUnknown methods */
 152     d3d11_blend_state_QueryInterface,
 153     d3d11_blend_state_AddRef,
 154     d3d11_blend_state_Release,
 155     /* ID3D11DeviceChild methods */
 156     d3d11_blend_state_GetDevice,
 157     d3d11_blend_state_GetPrivateData,
 158     d3d11_blend_state_SetPrivateData,
 159     d3d11_blend_state_SetPrivateDataInterface,
 160     /* ID3D11BlendState methods */
 161     d3d11_blend_state_GetDesc,
 162 };
 163
 164 /* ID3D10BlendState methods */
 165
 166 static inline struct d3d_blend_state *impl_from_ID3D10BlendState(ID3D10BlendState1 *iface)
 167 {
 168     return CONTAINING_RECORD(iface, struct d3d_blend_state, ID3D10BlendState1_iface);
 169 }
 170
 171 /* IUnknown methods */
 172
 173 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_QueryInterface(ID3D10BlendState1 *iface,
 174         REFIID riid, void **object)
 175 {
 176     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 177
 178     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 179
 180     return d3d11_blend_state_QueryInterface(&state->ID3D11BlendState_iface, riid, object);
 181 }
 182
 183 static ULONG STDMETHODCALLTYPE d3d10_blend_state_AddRef(ID3D10BlendState1 *iface)
 184 {
 185     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 186
 187     TRACE("iface %p.\n", iface);
 188
 189     return d3d11_blend_state_AddRef(&state->ID3D11BlendState_iface);
 190 }
 191
 192 static ULONG STDMETHODCALLTYPE d3d10_blend_state_Release(ID3D10BlendState1 *iface)
 193 {
 194     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 195
 196     TRACE("iface %p.\n", iface);
 197
 198     return d3d11_blend_state_Release(&state->ID3D11BlendState_iface);
 199 }
 200
 201 /* ID3D10DeviceChild methods */
 202
 203 static void STDMETHODCALLTYPE d3d10_blend_state_GetDevice(ID3D10BlendState1 *iface, ID3D10Device **device)
 204 {
 205     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 206
 207     TRACE("iface %p, device %p.\n", iface, device);
 208
 209     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 210 }
 211
 212 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_GetPrivateData(ID3D10BlendState1 *iface,
 213         REFGUID guid, UINT *data_size, void *data)
 214 {
 215     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 216
 217     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 218             iface, debugstr_guid(guid), data_size, data);
 219
 220     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 221 }
 222
 223 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateData(ID3D10BlendState1 *iface,
 224         REFGUID guid, UINT data_size, const void *data)
 225 {
 226     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 227
 228     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 229             iface, debugstr_guid(guid), data_size, data);
 230
 231     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 232 }
 233
 234 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateDataInterface(ID3D10BlendState1 *iface,
 235         REFGUID guid, const IUnknown *data)
 236 {
 237     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 238
 239     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 240
 241     return d3d_set_private_data_interface(&state->private_store, guid, data);
 242 }
 243
 244 /* ID3D10BlendState methods */
 245
 246 static void STDMETHODCALLTYPE d3d10_blend_state_GetDesc(ID3D10BlendState1 *iface, D3D10_BLEND_DESC *desc)
 247 {
 248     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 249     const D3D11_BLEND_DESC *d3d11_desc = &state->desc;
 250     unsigned int i;
 251
 252     TRACE("iface %p, desc %p.\n", iface, desc);
 253
 254     desc->AlphaToCoverageEnable = d3d11_desc->AlphaToCoverageEnable;
 255     desc->SrcBlend = d3d11_desc->RenderTarget[0].SrcBlend;
 256     desc->DestBlend = d3d11_desc->RenderTarget[0].DestBlend;
 257     desc->BlendOp = d3d11_desc->RenderTarget[0].BlendOp;
 258     desc->SrcBlendAlpha = d3d11_desc->RenderTarget[0].SrcBlendAlpha;
 259     desc->DestBlendAlpha = d3d11_desc->RenderTarget[0].DestBlendAlpha;
 260     desc->BlendOpAlpha = d3d11_desc->RenderTarget[0].BlendOpAlpha;
 261     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 262     {
 263         desc->BlendEnable[i] = d3d11_desc->RenderTarget[i].BlendEnable;
 264         desc->RenderTargetWriteMask[i] = d3d11_desc->RenderTarget[i].RenderTargetWriteMask;
 265     }
 266 }
 267
 268 static void STDMETHODCALLTYPE d3d10_blend_state_GetDesc1(ID3D10BlendState1 *iface, D3D10_BLEND_DESC1 *desc)
 269 {
 270     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 271
 272     TRACE("iface %p, desc %p.\n", iface, desc);
 273
 274     memcpy(desc, &state->desc, sizeof(*desc));
 275 }
 276
 277 static const struct ID3D10BlendState1Vtbl d3d10_blend_state_vtbl =
 278 {
 279     /* IUnknown methods */
 280     d3d10_blend_state_QueryInterface,
 281     d3d10_blend_state_AddRef,
 282     d3d10_blend_state_Release,
 283     /* ID3D10DeviceChild methods */
 284     d3d10_blend_state_GetDevice,
 285     d3d10_blend_state_GetPrivateData,
 286     d3d10_blend_state_SetPrivateData,
 287     d3d10_blend_state_SetPrivateDataInterface,
 288     /* ID3D10BlendState methods */
 289     d3d10_blend_state_GetDesc,
 290     /* ID3D10BlendState1 methods */
 291     d3d10_blend_state_GetDesc1,
 292 };
 293
 294 static void STDMETHODCALLTYPE d3d_blend_state_wined3d_object_destroyed(void *parent)
 295 {
 296     struct d3d_blend_state *state = parent;
 297     struct d3d_device *device = impl_from_ID3D11Device(state->device);
 298
 299     wine_rb_remove(&device->blend_states, &state->entry);
 300     wined3d_private_store_cleanup(&state->private_store);
 301     heap_free(parent);
 302 }
 303
 304 static const struct wined3d_parent_ops d3d_blend_state_wined3d_parent_ops =
 305 {
 306     d3d_blend_state_wined3d_object_destroyed,
 307 };
 308
 309 HRESULT d3d_blend_state_create(struct d3d_device *device, const D3D11_BLEND_DESC *desc,
 310         struct d3d_blend_state **state)
 311 {
 312     struct wined3d_blend_state_desc wined3d_desc;
 313     struct d3d_blend_state *object;
 314     struct wine_rb_entry *entry;
 315     D3D11_BLEND_DESC tmp_desc;
 316     unsigned int i, j;
 317     HRESULT hr;
 318
 319     if (!desc)
 320         return E_INVALIDARG;
 321
 322     /* D3D11_RENDER_TARGET_BLEND_DESC has a hole, which is a problem because we use
 323      * D3D11_BLEND_DESC as a key in the rbtree. */
 324     memset(&tmp_desc, 0, sizeof(tmp_desc));
 325     tmp_desc.AlphaToCoverageEnable = desc->AlphaToCoverageEnable;
 326     tmp_desc.IndependentBlendEnable = desc->IndependentBlendEnable;
 327     for (i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 328     {
 329         j = desc->IndependentBlendEnable ? i : 0;
 330         tmp_desc.RenderTarget[i].BlendEnable = desc->RenderTarget[j].BlendEnable;
 331         tmp_desc.RenderTarget[i].SrcBlend = desc->RenderTarget[j].SrcBlend;
 332         tmp_desc.RenderTarget[i].DestBlend = desc->RenderTarget[j].DestBlend;
 333         tmp_desc.RenderTarget[i].BlendOp = desc->RenderTarget[j].BlendOp;
 334         tmp_desc.RenderTarget[i].SrcBlendAlpha = desc->RenderTarget[j].SrcBlendAlpha;
 335         tmp_desc.RenderTarget[i].DestBlendAlpha = desc->RenderTarget[j].DestBlendAlpha;
 336         tmp_desc.RenderTarget[i].BlendOpAlpha = desc->RenderTarget[j].BlendOpAlpha;
 337         tmp_desc.RenderTarget[i].RenderTargetWriteMask = desc->RenderTarget[j].RenderTargetWriteMask;
 338
 339         if (i > 3 && tmp_desc.RenderTarget[i].RenderTargetWriteMask != D3D11_COLOR_WRITE_ENABLE_ALL)
 340             FIXME("Color mask %#x not supported for render target %u.\n",
 341                     tmp_desc.RenderTarget[i].RenderTargetWriteMask, i);
 342     }
 343
 344     /* glEnableIndexedEXT(GL_BLEND, ...) */
 345     if (tmp_desc.IndependentBlendEnable)
 346         FIXME("Per-rendertarget blend not implemented.\n");
 347
 348     wined3d_mutex_lock();
 349     if ((entry = wine_rb_get(&device->blend_states, &tmp_desc)))
 350     {
 351         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_blend_state, entry);
 352
 353         TRACE("Returning existing blend state %p.\n", object);
 354         ID3D11BlendState_AddRef(&object->ID3D11BlendState_iface);
 355         *state = object;
 356         wined3d_mutex_unlock();
 357
 358         return S_OK;
 359     }
 360
 361     if (!(object = heap_alloc_zero(sizeof(*object))))
 362     {
 363         wined3d_mutex_unlock();
 364         return E_OUTOFMEMORY;
 365     }
 366
 367     object->ID3D11BlendState_iface.lpVtbl = &d3d11_blend_state_vtbl;
 368     object->ID3D10BlendState1_iface.lpVtbl = &d3d10_blend_state_vtbl;
 369     object->refcount = 1;
 370     wined3d_private_store_init(&object->private_store);
 371     object->desc = tmp_desc;
 372
 373     if (wine_rb_put(&device->blend_states, &tmp_desc, &object->entry) == -1)
 374     {
 375         ERR("Failed to insert blend state entry.\n");
 376         wined3d_private_store_cleanup(&object->private_store);
 377         heap_free(object);
 378         wined3d_mutex_unlock();
 379         return E_FAIL;
 380     }
 381
 382     wined3d_desc.alpha_to_coverage = desc->AlphaToCoverageEnable;
 383
 384     /* We cannot fail after creating a wined3d_blend_state object. It
 385      * would lead to double free. */
 386     if (FAILED(hr = wined3d_blend_state_create(device->wined3d_device, &wined3d_desc,
 387             object, &d3d_blend_state_wined3d_parent_ops, &object->wined3d_state)))
 388     {
 389         WARN("Failed to create wined3d blend state, hr %#x.\n", hr);
 390         wined3d_private_store_cleanup(&object->private_store);
 391         wine_rb_remove(&device->blend_states, &object->entry);
 392         heap_free(object);
 393         wined3d_mutex_unlock();
 394         return hr;
 395     }
 396     wined3d_mutex_unlock();
 397
 398     ID3D11Device_AddRef(object->device = &device->ID3D11Device_iface);
 399
 400     TRACE("Created blend state %p.\n", object);
 401     *state = object;
 402
 403     return S_OK;
 404 }
 405
 406 struct d3d_blend_state *unsafe_impl_from_ID3D11BlendState(ID3D11BlendState *iface)
 407 {
 408     if (!iface)
 409         return NULL;
 410     assert(iface->lpVtbl == &d3d11_blend_state_vtbl);
 411
 412     return impl_from_ID3D11BlendState(iface);
 413 }
 414
 415 struct d3d_blend_state *unsafe_impl_from_ID3D10BlendState(ID3D10BlendState *iface)
 416 {
 417     if (!iface)
 418         return NULL;
 419     assert(iface->lpVtbl == (ID3D10BlendStateVtbl *)&d3d10_blend_state_vtbl);
 420
 421     return impl_from_ID3D10BlendState((ID3D10BlendState1 *)iface);
 422 }
 423
 424 /* ID3D11DepthStencilState methods */
 425
 426 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_QueryInterface(ID3D11DepthStencilState *iface,
 427         REFIID riid, void **object)
 428 {
 429     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 430
 431     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 432
 433     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilState)
 434             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 435             || IsEqualGUID(riid, &IID_IUnknown))
 436     {
 437         ID3D11DepthStencilState_AddRef(iface);
 438         *object = iface;
 439         return S_OK;
 440     }
 441
 442     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilState)
 443             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 444     {
 445         ID3D10DepthStencilState_AddRef(&state->ID3D10DepthStencilState_iface);
 446         *object = &state->ID3D10DepthStencilState_iface;
 447         return S_OK;
 448     }
 449
 450     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 451
 452     *object = NULL;
 453     return E_NOINTERFACE;
 454 }
 455
 456 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_state_AddRef(ID3D11DepthStencilState *iface)
 457 {
 458     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 459     ULONG refcount = InterlockedIncrement(&state->refcount);
 460
 461     TRACE("%p increasing refcount to %u.\n", state, refcount);
 462
 463     return refcount;
 464 }
 465
 466 static void d3d_depthstencil_state_cleanup(struct d3d_depthstencil_state *state)
 467 {
 468     wined3d_private_store_cleanup(&state->private_store);
 469     ID3D11Device_Release(state->device);
 470 }
 471
 472 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_state_Release(ID3D11DepthStencilState *iface)
 473 {
 474     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 475     ULONG refcount = InterlockedDecrement(&state->refcount);
 476
 477     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 478
 479     if (!refcount)
 480     {
 481         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 482         wined3d_mutex_lock();
 483         wine_rb_remove(&device->depthstencil_states, &state->entry);
 484         d3d_depthstencil_state_cleanup(state);
 485         wined3d_mutex_unlock();
 486         heap_free(state);
 487     }
 488
 489     return refcount;
 490 }
 491
 492 static void STDMETHODCALLTYPE d3d11_depthstencil_state_GetDevice(ID3D11DepthStencilState *iface,
 493         ID3D11Device **device)
 494 {
 495     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 496
 497     TRACE("iface %p, device %p.\n", iface, device);
 498
 499     *device = state->device;
 500     ID3D11Device_AddRef(*device);
 501 }
 502
 503 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_GetPrivateData(ID3D11DepthStencilState *iface,
 504         REFGUID guid, UINT *data_size, void *data)
 505 {
 506     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 507
 508     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 509
 510     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 511 }
 512
 513 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_SetPrivateData(ID3D11DepthStencilState *iface,
 514         REFGUID guid, UINT data_size, const void *data)
 515 {
 516     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 517
 518     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 519
 520     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 521 }
 522
 523 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_SetPrivateDataInterface(ID3D11DepthStencilState *iface,
 524         REFGUID guid, const IUnknown *data)
 525 {
 526     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 527
 528     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 529
 530     return d3d_set_private_data_interface(&state->private_store, guid, data);
 531 }
 532
 533 static void STDMETHODCALLTYPE d3d11_depthstencil_state_GetDesc(ID3D11DepthStencilState *iface,
 534         D3D11_DEPTH_STENCIL_DESC *desc)
 535 {
 536     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 537
 538     TRACE("iface %p, desc %p.\n", iface, desc);
 539
 540     *desc = state->desc;
 541 }
 542
 543 static const struct ID3D11DepthStencilStateVtbl d3d11_depthstencil_state_vtbl =
 544 {
 545     /* IUnknown methods */
 546     d3d11_depthstencil_state_QueryInterface,
 547     d3d11_depthstencil_state_AddRef,
 548     d3d11_depthstencil_state_Release,
 549     /* ID3D11DeviceChild methods */
 550     d3d11_depthstencil_state_GetDevice,
 551     d3d11_depthstencil_state_GetPrivateData,
 552     d3d11_depthstencil_state_SetPrivateData,
 553     d3d11_depthstencil_state_SetPrivateDataInterface,
 554     /* ID3D11DepthStencilState methods */
 555     d3d11_depthstencil_state_GetDesc,
 556 };
 557
 558 /* ID3D10DepthStencilState methods */
 559
 560 static inline struct d3d_depthstencil_state *impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 561 {
 562     return CONTAINING_RECORD(iface, struct d3d_depthstencil_state, ID3D10DepthStencilState_iface);
 563 }
 564
 565 /* IUnknown methods */
 566
 567 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_QueryInterface(ID3D10DepthStencilState *iface,
 568         REFIID riid, void **object)
 569 {
 570     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 571
 572     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 573
 574     return d3d11_depthstencil_state_QueryInterface(&state->ID3D11DepthStencilState_iface, riid, object);
 575 }
 576
 577 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_AddRef(ID3D10DepthStencilState *iface)
 578 {
 579     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 580
 581     TRACE("iface %p.\n", iface);
 582
 583     return d3d11_depthstencil_state_AddRef(&state->ID3D11DepthStencilState_iface);
 584 }
 585
 586 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_Release(ID3D10DepthStencilState *iface)
 587 {
 588     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 589
 590     TRACE("iface %p.\n", iface);
 591
 592     return d3d11_depthstencil_state_Release(&state->ID3D11DepthStencilState_iface);
 593 }
 594
 595 /* ID3D10DeviceChild methods */
 596
 597 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDevice(ID3D10DepthStencilState *iface, ID3D10Device **device)
 598 {
 599     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 600
 601     TRACE("iface %p, device %p.\n", iface, device);
 602
 603     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 604 }
 605
 606 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_GetPrivateData(ID3D10DepthStencilState *iface,
 607         REFGUID guid, UINT *data_size, void *data)
 608 {
 609     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 610
 611     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 612             iface, debugstr_guid(guid), data_size, data);
 613
 614     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 615 }
 616
 617 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateData(ID3D10DepthStencilState *iface,
 618         REFGUID guid, UINT data_size, const void *data)
 619 {
 620     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 621
 622     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 623             iface, debugstr_guid(guid), data_size, data);
 624
 625     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 626 }
 627
 628 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateDataInterface(ID3D10DepthStencilState *iface,
 629         REFGUID guid, const IUnknown *data)
 630 {
 631     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 632
 633     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 634
 635     return d3d_set_private_data_interface(&state->private_store, guid, data);
 636 }
 637
 638 /* ID3D10DepthStencilState methods */
 639
 640 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDesc(ID3D10DepthStencilState *iface,
 641         D3D10_DEPTH_STENCIL_DESC *desc)
 642 {
 643     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 644
 645     TRACE("iface %p, desc %p.\n", iface, desc);
 646
 647     memcpy(desc, &state->desc, sizeof(*desc));
 648 }
 649
 650 static const struct ID3D10DepthStencilStateVtbl d3d10_depthstencil_state_vtbl =
 651 {
 652     /* IUnknown methods */
 653     d3d10_depthstencil_state_QueryInterface,
 654     d3d10_depthstencil_state_AddRef,
 655     d3d10_depthstencil_state_Release,
 656     /* ID3D10DeviceChild methods */
 657     d3d10_depthstencil_state_GetDevice,
 658     d3d10_depthstencil_state_GetPrivateData,
 659     d3d10_depthstencil_state_SetPrivateData,
 660     d3d10_depthstencil_state_SetPrivateDataInterface,
 661     /* ID3D10DepthStencilState methods */
 662     d3d10_depthstencil_state_GetDesc,
 663 };
 664
 665 static HRESULT d3d_depthstencil_state_init(struct d3d_depthstencil_state *state, struct d3d_device *device,
 666         const D3D11_DEPTH_STENCIL_DESC *desc)
 667 {
 668     state->ID3D11DepthStencilState_iface.lpVtbl = &d3d11_depthstencil_state_vtbl;
 669     state->ID3D10DepthStencilState_iface.lpVtbl = &d3d10_depthstencil_state_vtbl;
 670     state->refcount = 1;
 671     wined3d_private_store_init(&state->private_store);
 672     state->desc = *desc;
 673
 674     state->device = &device->ID3D11Device_iface;
 675     ID3D11Device_AddRef(state->device);
 676
 677     return S_OK;
 678 }
 679
 680 HRESULT d3d_depthstencil_state_create(struct d3d_device *device, const D3D11_DEPTH_STENCIL_DESC *desc,
 681         struct d3d_depthstencil_state **state)
 682 {
 683     struct d3d_depthstencil_state *object;
 684     D3D11_DEPTH_STENCIL_DESC tmp_desc;
 685     struct wine_rb_entry *entry;
 686     HRESULT hr;
 687
 688     if (!desc)
 689         return E_INVALIDARG;
 690
 691     /* D3D11_DEPTH_STENCIL_DESC has a hole, which is a problem because we use
 692      * it as a key in the rbtree. */
 693     memset(&tmp_desc, 0, sizeof(tmp_desc));
 694     tmp_desc.DepthEnable = desc->DepthEnable;
 695     if (desc->DepthEnable)
 696     {
 697         tmp_desc.DepthWriteMask = desc->DepthWriteMask;
 698         tmp_desc.DepthFunc = desc->DepthFunc;
 699     }
 700     else
 701     {
 702         tmp_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
 703         tmp_desc.DepthFunc = D3D11_COMPARISON_LESS;
 704     }
 705     tmp_desc.StencilEnable = desc->StencilEnable;
 706     if (desc->StencilEnable)
 707     {
 708         tmp_desc.StencilReadMask = desc->StencilReadMask;
 709         tmp_desc.StencilWriteMask = desc->StencilWriteMask;
 710         tmp_desc.FrontFace = desc->FrontFace;
 711         tmp_desc.BackFace = desc->BackFace;
 712     }
 713     else
 714     {
 715         tmp_desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
 716         tmp_desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
 717         tmp_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
 718         tmp_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
 719         tmp_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
 720         tmp_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 721         tmp_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
 722         tmp_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
 723         tmp_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
 724         tmp_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
 725     }
 726
 727     wined3d_mutex_lock();
 728     if ((entry = wine_rb_get(&device->depthstencil_states, &tmp_desc)))
 729     {
 730         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_depthstencil_state, entry);
 731
 732         TRACE("Returning existing depthstencil state %p.\n", object);
 733         ID3D11DepthStencilState_AddRef(&object->ID3D11DepthStencilState_iface);
 734         *state = object;
 735         wined3d_mutex_unlock();
 736
 737         return S_OK;
 738     }
 739
 740     if (!(object = heap_alloc_zero(sizeof(*object))))
 741     {
 742         wined3d_mutex_unlock();
 743         return E_OUTOFMEMORY;
 744     }
 745
 746     if (FAILED(hr = d3d_depthstencil_state_init(object, device, &tmp_desc)))
 747     {
 748         WARN("Failed to initialize depthstencil state, hr %#x.\n", hr);
 749         heap_free(object);
 750         wined3d_mutex_unlock();
 751         return hr;
 752     }
 753
 754     if (wine_rb_put(&device->depthstencil_states, desc, &object->entry) == -1)
 755     {
 756         ERR("Failed to insert depthstencil state entry.\n");
 757         d3d_depthstencil_state_cleanup(object);
 758         heap_free(object);
 759         wined3d_mutex_unlock();
 760         return E_FAIL;
 761     }
 762     wined3d_mutex_unlock();
 763
 764     TRACE("Created depthstencil state %p.\n", object);
 765     *state = object;
 766
 767     return S_OK;
 768 }
 769
 770 struct d3d_depthstencil_state *unsafe_impl_from_ID3D11DepthStencilState(ID3D11DepthStencilState *iface)
 771 {
 772     if (!iface)
 773         return NULL;
 774     assert(iface->lpVtbl == &d3d11_depthstencil_state_vtbl);
 775
 776     return impl_from_ID3D11DepthStencilState(iface);
 777 }
 778
 779 struct d3d_depthstencil_state *unsafe_impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 780 {
 781     if (!iface)
 782         return NULL;
 783     assert(iface->lpVtbl == &d3d10_depthstencil_state_vtbl);
 784
 785     return impl_from_ID3D10DepthStencilState(iface);
 786 }
 787
 788 /* ID3D11RasterizerState methods */
 789
 790 static inline struct d3d_rasterizer_state *impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
 791 {
 792     return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D11RasterizerState_iface);
 793 }
 794
 795 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11RasterizerState *iface,
 796         REFIID riid, void **object)
 797 {
 798     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 799
 800     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 801
 802     if (IsEqualGUID(riid, &IID_ID3D11RasterizerState)
 803             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 804             || IsEqualGUID(riid, &IID_IUnknown))
 805     {
 806         ID3D11RasterizerState_AddRef(iface);
 807         *object = iface;
 808         return S_OK;
 809     }
 810
 811     if (IsEqualGUID(riid, &IID_ID3D10RasterizerState)
 812             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 813     {
 814         ID3D10RasterizerState_AddRef(&state->ID3D10RasterizerState_iface);
 815         *object = &state->ID3D10RasterizerState_iface;
 816         return S_OK;
 817     }
 818
 819     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 820
 821     *object = NULL;
 822     return E_NOINTERFACE;
 823 }
 824
 825 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerState *iface)
 826 {
 827     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 828     ULONG refcount = InterlockedIncrement(&state->refcount);
 829
 830     TRACE("%p increasing refcount to %u.\n", state, refcount);
 831
 832     if (refcount == 1)
 833     {
 834         ID3D11Device_AddRef(state->device);
 835         wined3d_mutex_lock();
 836         wined3d_rasterizer_state_incref(state->wined3d_state);
 837         wined3d_mutex_unlock();
 838     }
 839
 840     return refcount;
 841 }
 842
 843 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerState *iface)
 844 {
 845     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 846     ULONG refcount = InterlockedDecrement(&state->refcount);
 847
 848     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 849
 850     if (!refcount)
 851     {
 852         ID3D11Device *device = state->device;
 853
 854         wined3d_mutex_lock();
 855         wined3d_rasterizer_state_decref(state->wined3d_state);
 856         wined3d_mutex_unlock();
 857
 858         ID3D11Device_Release(device);
 859     }
 860
 861     return refcount;
 862 }
 863
 864 static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDevice(ID3D11RasterizerState *iface,
 865         ID3D11Device **device)
 866 {
 867     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 868
 869     TRACE("iface %p, device %p.\n", iface, device);
 870
 871     *device = state->device;
 872     ID3D11Device_AddRef(*device);
 873 }
 874
 875 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_GetPrivateData(ID3D11RasterizerState *iface,
 876         REFGUID guid, UINT *data_size, void *data)
 877 {
 878     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 879
 880     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 881
 882     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 883 }
 884
 885 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateData(ID3D11RasterizerState *iface,
 886         REFGUID guid, UINT data_size, const void *data)
 887 {
 888     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 889
 890     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 891
 892     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 893 }
 894
 895 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateDataInterface(ID3D11RasterizerState *iface,
 896         REFGUID guid, const IUnknown *data)
 897 {
 898     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 899
 900     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 901
 902     return d3d_set_private_data_interface(&state->private_store, guid, data);
 903 }
 904
 905 static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc(ID3D11RasterizerState *iface,
 906         D3D11_RASTERIZER_DESC *desc)
 907 {
 908     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 909
 910     TRACE("iface %p, desc %p.\n", iface, desc);
 911
 912     *desc = state->desc;
 913 }
 914
 915 static const struct ID3D11RasterizerStateVtbl d3d11_rasterizer_state_vtbl =
 916 {
 917     /* IUnknown methods */
 918     d3d11_rasterizer_state_QueryInterface,
 919     d3d11_rasterizer_state_AddRef,
 920     d3d11_rasterizer_state_Release,
 921     /* ID3D11DeviceChild methods */
 922     d3d11_rasterizer_state_GetDevice,
 923     d3d11_rasterizer_state_GetPrivateData,
 924     d3d11_rasterizer_state_SetPrivateData,
 925     d3d11_rasterizer_state_SetPrivateDataInterface,
 926     /* ID3D11RasterizerState methods */
 927     d3d11_rasterizer_state_GetDesc,
 928 };
 929
 930 /* ID3D10RasterizerState methods */
 931
 932 static inline struct d3d_rasterizer_state *impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 933 {
 934     return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D10RasterizerState_iface);
 935 }
 936
 937 /* IUnknown methods */
 938
 939 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_QueryInterface(ID3D10RasterizerState *iface,
 940         REFIID riid, void **object)
 941 {
 942     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 943
 944     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 945
 946     return d3d11_rasterizer_state_QueryInterface(&state->ID3D11RasterizerState_iface, riid, object);
 947 }
 948
 949 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_AddRef(ID3D10RasterizerState *iface)
 950 {
 951     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 952
 953     TRACE("iface %p.\n", iface);
 954
 955     return d3d11_rasterizer_state_AddRef(&state->ID3D11RasterizerState_iface);
 956 }
 957
 958 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_Release(ID3D10RasterizerState *iface)
 959 {
 960     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 961
 962     TRACE("iface %p.\n", state);
 963
 964     return d3d11_rasterizer_state_Release(&state->ID3D11RasterizerState_iface);
 965 }
 966
 967 /* ID3D10DeviceChild methods */
 968
 969 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDevice(ID3D10RasterizerState *iface, ID3D10Device **device)
 970 {
 971     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 972
 973     TRACE("iface %p, device %p.\n", iface, device);
 974
 975     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 976 }
 977
 978 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_GetPrivateData(ID3D10RasterizerState *iface,
 979         REFGUID guid, UINT *data_size, void *data)
 980 {
 981     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 982
 983     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 984             iface, debugstr_guid(guid), data_size, data);
 985
 986     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 987 }
 988
 989 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateData(ID3D10RasterizerState *iface,
 990         REFGUID guid, UINT data_size, const void *data)
 991 {
 992     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 993
 994     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 995             iface, debugstr_guid(guid), data_size, data);
 996
 997     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 998 }
 999
1000 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateDataInterface(ID3D10RasterizerState *iface,
1001         REFGUID guid, const IUnknown *data)
1002 {
1003     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
1004
1005     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1006
1007     return d3d_set_private_data_interface(&state->private_store, guid, data);
1008 }
1009
1010 /* ID3D10RasterizerState methods */
1011
1012 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDesc(ID3D10RasterizerState *iface,
1013         D3D10_RASTERIZER_DESC *desc)
1014 {
1015     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
1016
1017     TRACE("iface %p, desc %p.\n", iface, desc);
1018
1019     memcpy(desc, &state->desc, sizeof(*desc));
1020 }
1021
1022 static const struct ID3D10RasterizerStateVtbl d3d10_rasterizer_state_vtbl =
1023 {
1024     /* IUnknown methods */
1025     d3d10_rasterizer_state_QueryInterface,
1026     d3d10_rasterizer_state_AddRef,
1027     d3d10_rasterizer_state_Release,
1028     /* ID3D10DeviceChild methods */
1029     d3d10_rasterizer_state_GetDevice,
1030     d3d10_rasterizer_state_GetPrivateData,
1031     d3d10_rasterizer_state_SetPrivateData,
1032     d3d10_rasterizer_state_SetPrivateDataInterface,
1033     /* ID3D10RasterizerState methods */
1034     d3d10_rasterizer_state_GetDesc,
1035 };
1036
1037 static void STDMETHODCALLTYPE d3d_rasterizer_state_wined3d_object_destroyed(void *parent)
1038 {
1039     struct d3d_rasterizer_state *state = parent;
1040     struct d3d_device *device = impl_from_ID3D11Device(state->device);
1041
1042     wine_rb_remove(&device->rasterizer_states, &state->entry);
1043     wined3d_private_store_cleanup(&state->private_store);
1044     heap_free(parent);
1045 }
1046
1047 static const struct wined3d_parent_ops d3d_rasterizer_state_wined3d_parent_ops =
1048 {
1049     d3d_rasterizer_state_wined3d_object_destroyed,
1050 };
1051
1052 static HRESULT d3d_rasterizer_state_init(struct d3d_rasterizer_state *state, struct d3d_device *device,
1053         const D3D11_RASTERIZER_DESC *desc)
1054 {
1055     struct wined3d_rasterizer_state_desc wined3d_desc;
1056     HRESULT hr;
1057
1058     state->ID3D11RasterizerState_iface.lpVtbl = &d3d11_rasterizer_state_vtbl;
1059     state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
1060     state->refcount = 1;
1061     wined3d_private_store_init(&state->private_store);
1062     state->desc = *desc;
1063
1064     if (wine_rb_put(&device->rasterizer_states, desc, &state->entry) == -1)
1065     {
1066         ERR("Failed to insert rasterizer state entry.\n");
1067         wined3d_private_store_cleanup(&state->private_store);
1068         return E_FAIL;
1069     }
1070
1071     wined3d_desc.front_ccw = desc->FrontCounterClockwise;
1072
1073     /* We cannot fail after creating a wined3d_rasterizer_state object. It
1074      * would lead to double free. */
1075     if (FAILED(hr = wined3d_rasterizer_state_create(device->wined3d_device, &wined3d_desc,
1076             state, &d3d_rasterizer_state_wined3d_parent_ops, &state->wined3d_state)))
1077     {
1078         WARN("Failed to create wined3d rasterizer state, hr %#x.\n", hr);
1079         wined3d_private_store_cleanup(&state->private_store);
1080         wine_rb_remove(&device->rasterizer_states, &state->entry);
1081         return hr;
1082     }
1083
1084     ID3D11Device_AddRef(state->device = &device->ID3D11Device_iface);
1085
1086     return S_OK;
1087 }
1088
1089 HRESULT d3d_rasterizer_state_create(struct d3d_device *device, const D3D11_RASTERIZER_DESC *desc,
1090         struct d3d_rasterizer_state **state)
1091 {
1092     struct d3d_rasterizer_state *object;
1093     struct wine_rb_entry *entry;
1094     HRESULT hr;
1095
1096     if (!desc)
1097         return E_INVALIDARG;
1098
1099     wined3d_mutex_lock();
1100     if ((entry = wine_rb_get(&device->rasterizer_states, desc)))
1101     {
1102         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_rasterizer_state, entry);
1103
1104         TRACE("Returning existing rasterizer state %p.\n", object);
1105         ID3D11RasterizerState_AddRef(&object->ID3D11RasterizerState_iface);
1106         *state = object;
1107         wined3d_mutex_unlock();
1108
1109         return S_OK;
1110     }
1111
1112     if (!(object = heap_alloc_zero(sizeof(*object))))
1113     {
1114         wined3d_mutex_unlock();
1115         return E_OUTOFMEMORY;
1116     }
1117
1118     hr = d3d_rasterizer_state_init(object, device, desc);
1119     wined3d_mutex_unlock();
1120     if (FAILED(hr))
1121     {
1122         WARN("Failed to initialize rasterizer state, hr %#x.\n", hr);
1123         heap_free(object);
1124         return hr;
1125     }
1126
1127     TRACE("Created rasterizer state %p.\n", object);
1128     *state = object;
1129
1130     return S_OK;
1131 }
1132
1133 struct d3d_rasterizer_state *unsafe_impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
1134 {
1135     if (!iface)
1136         return NULL;
1137     assert(iface->lpVtbl == &d3d11_rasterizer_state_vtbl);
1138
1139     return impl_from_ID3D11RasterizerState(iface);
1140 }
1141
1142 struct d3d_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
1143 {
1144     if (!iface)
1145         return NULL;
1146     assert(iface->lpVtbl == &d3d10_rasterizer_state_vtbl);
1147
1148     return impl_from_ID3D10RasterizerState(iface);
1149 }
1150
1151 /* ID3D11SampleState methods */
1152
1153 static inline struct d3d_sampler_state *impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
1154 {
1155     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D11SamplerState_iface);
1156 }
1157
1158 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_QueryInterface(ID3D11SamplerState *iface,
1159         REFIID riid, void **object)
1160 {
1161     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1162
1163     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1164
1165     if (IsEqualGUID(riid, &IID_ID3D11SamplerState)
1166             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1167             || IsEqualGUID(riid, &IID_IUnknown))
1168     {
1169         ID3D11SamplerState_AddRef(iface);
1170         *object = iface;
1171         return S_OK;
1172     }
1173
1174     if (IsEqualGUID(riid, &IID_ID3D10SamplerState)
1175             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1176     {
1177         ID3D10SamplerState_AddRef(&state->ID3D10SamplerState_iface);
1178         *object = &state->ID3D10SamplerState_iface;
1179         return S_OK;
1180     }
1181
1182     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1183
1184     *object = NULL;
1185     return E_NOINTERFACE;
1186 }
1187
1188 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_AddRef(ID3D11SamplerState *iface)
1189 {
1190     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1191     ULONG refcount = InterlockedIncrement(&state->refcount);
1192
1193     TRACE("%p increasing refcount to %u.\n", state, refcount);
1194
1195     if (refcount == 1)
1196     {
1197         ID3D11Device_AddRef(state->device);
1198         wined3d_mutex_lock();
1199         wined3d_sampler_incref(state->wined3d_sampler);
1200         wined3d_mutex_unlock();
1201     }
1202
1203     return refcount;
1204 }
1205
1206 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_Release(ID3D11SamplerState *iface)
1207 {
1208     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1209     ULONG refcount = InterlockedDecrement(&state->refcount);
1210
1211     TRACE("%p decreasing refcount to %u.\n", state, refcount);
1212
1213     if (!refcount)
1214     {
1215         ID3D11Device *device = state->device;
1216
1217         wined3d_mutex_lock();
1218         wined3d_sampler_decref(state->wined3d_sampler);
1219         wined3d_mutex_unlock();
1220
1221         ID3D11Device_Release(device);
1222     }
1223
1224     return refcount;
1225 }
1226
1227 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDevice(ID3D11SamplerState *iface,
1228         ID3D11Device **device)
1229 {
1230     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1231
1232     TRACE("iface %p, device %p.\n", iface, device);
1233
1234     *device = state->device;
1235     ID3D11Device_AddRef(*device);
1236 }
1237
1238 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_GetPrivateData(ID3D11SamplerState *iface,
1239         REFGUID guid, UINT *data_size, void *data)
1240 {
1241     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1242
1243     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1244
1245     return d3d_get_private_data(&state->private_store, guid, data_size, data);
1246 }
1247
1248 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateData(ID3D11SamplerState *iface,
1249         REFGUID guid, UINT data_size, const void *data)
1250 {
1251     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1252
1253     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1254
1255     return d3d_set_private_data(&state->private_store, guid, data_size, data);
1256 }
1257
1258 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateDataInterface(ID3D11SamplerState *iface,
1259         REFGUID guid, const IUnknown *data)
1260 {
1261     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1262
1263     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1264
1265     return d3d_set_private_data_interface(&state->private_store, guid, data);
1266 }
1267
1268 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDesc(ID3D11SamplerState *iface,
1269         D3D11_SAMPLER_DESC *desc)
1270 {
1271     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1272
1273     TRACE("iface %p, desc %p.\n", iface, desc);
1274
1275     *desc = state->desc;
1276 }
1277
1278 static const struct ID3D11SamplerStateVtbl d3d11_sampler_state_vtbl =
1279 {
1280     /* IUnknown methods */
1281     d3d11_sampler_state_QueryInterface,
1282     d3d11_sampler_state_AddRef,
1283     d3d11_sampler_state_Release,
1284     /* ID3D11DeviceChild methods */
1285     d3d11_sampler_state_GetDevice,
1286     d3d11_sampler_state_GetPrivateData,
1287     d3d11_sampler_state_SetPrivateData,
1288     d3d11_sampler_state_SetPrivateDataInterface,
1289     /* ID3D11SamplerState methods */
1290     d3d11_sampler_state_GetDesc,
1291 };
1292
1293 /* ID3D10SamplerState methods */
1294
1295 static inline struct d3d_sampler_state *impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1296 {
1297     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D10SamplerState_iface);
1298 }
1299
1300 /* IUnknown methods */
1301
1302 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_QueryInterface(ID3D10SamplerState *iface,
1303         REFIID riid, void **object)
1304 {
1305     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1306
1307     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1308
1309     return d3d11_sampler_state_QueryInterface(&state->ID3D11SamplerState_iface, riid, object);
1310 }
1311
1312 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_AddRef(ID3D10SamplerState *iface)
1313 {
1314     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1315
1316     TRACE("iface %p.\n", iface);
1317
1318     return d3d11_sampler_state_AddRef(&state->ID3D11SamplerState_iface);
1319 }
1320
1321 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_Release(ID3D10SamplerState *iface)
1322 {
1323     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1324
1325     TRACE("iface %p.\n", iface);
1326
1327     return d3d11_sampler_state_Release(&state->ID3D11SamplerState_iface);
1328 }
1329
1330 /* ID3D10DeviceChild methods */
1331
1332 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDevice(ID3D10SamplerState *iface, ID3D10Device **device)
1333 {
1334     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1335
1336     TRACE("iface %p, device %p.\n", iface, device);
1337
1338     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
1339 }
1340
1341 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_GetPrivateData(ID3D10SamplerState *iface,
1342         REFGUID guid, UINT *data_size, void *data)
1343 {
1344     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1345
1346     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1347             iface, debugstr_guid(guid), data_size, data);
1348
1349     return d3d_get_private_data(&state->private_store, guid, data_size, data);
1350 }
1351
1352 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateData(ID3D10SamplerState *iface,
1353         REFGUID guid, UINT data_size, const void *data)
1354 {
1355     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1356
1357     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1358             iface, debugstr_guid(guid), data_size, data);
1359
1360     return d3d_set_private_data(&state->private_store, guid, data_size, data);
1361 }
1362
1363 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateDataInterface(ID3D10SamplerState *iface,
1364         REFGUID guid, const IUnknown *data)
1365 {
1366     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1367
1368     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1369
1370     return d3d_set_private_data_interface(&state->private_store, guid, data);
1371 }
1372
1373 /* ID3D10SamplerState methods */
1374
1375 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDesc(ID3D10SamplerState *iface,
1376         D3D10_SAMPLER_DESC *desc)
1377 {
1378     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1379
1380     TRACE("iface %p, desc %p.\n", iface, desc);
1381
1382     memcpy(desc, &state->desc, sizeof(*desc));
1383 }
1384
1385 static const struct ID3D10SamplerStateVtbl d3d10_sampler_state_vtbl =
1386 {
1387     /* IUnknown methods */
1388     d3d10_sampler_state_QueryInterface,
1389     d3d10_sampler_state_AddRef,
1390     d3d10_sampler_state_Release,
1391     /* ID3D10DeviceChild methods */
1392     d3d10_sampler_state_GetDevice,
1393     d3d10_sampler_state_GetPrivateData,
1394     d3d10_sampler_state_SetPrivateData,
1395     d3d10_sampler_state_SetPrivateDataInterface,
1396     /* ID3D10SamplerState methods */
1397     d3d10_sampler_state_GetDesc,
1398 };
1399
1400 static void STDMETHODCALLTYPE d3d_sampler_wined3d_object_destroyed(void *parent)
1401 {
1402     struct d3d_sampler_state *state = parent;
1403     struct d3d_device *device = impl_from_ID3D11Device(state->device);
1404
1405     wine_rb_remove(&device->sampler_states, &state->entry);
1406     wined3d_private_store_cleanup(&state->private_store);
1407     heap_free(parent);
1408 }
1409
1410 static const struct wined3d_parent_ops d3d_sampler_wined3d_parent_ops =
1411 {
1412     d3d_sampler_wined3d_object_destroyed,
1413 };
1414
1415 static enum wined3d_texture_address wined3d_texture_address_from_d3d11(enum D3D11_TEXTURE_ADDRESS_MODE t)
1416 {
1417     return (enum wined3d_texture_address)t;
1418 }
1419
1420 static enum wined3d_texture_filter_type wined3d_texture_filter_mip_from_d3d11(enum D3D11_FILTER f)
1421 {
1422     if (D3D11_DECODE_MIP_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1423         return WINED3D_TEXF_LINEAR;
1424     return WINED3D_TEXF_POINT;
1425 }
1426
1427 static enum wined3d_texture_filter_type wined3d_texture_filter_mag_from_d3d11(enum D3D11_FILTER f)
1428 {
1429     if (D3D11_DECODE_MAG_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1430         return WINED3D_TEXF_LINEAR;
1431     return WINED3D_TEXF_POINT;
1432 }
1433
1434 static enum wined3d_texture_filter_type wined3d_texture_filter_min_from_d3d11(enum D3D11_FILTER f)
1435 {
1436     if (D3D11_DECODE_MIN_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1437         return WINED3D_TEXF_LINEAR;
1438     return WINED3D_TEXF_POINT;
1439 }
1440
1441 static BOOL wined3d_texture_compare_from_d3d11(enum D3D11_FILTER f)
1442 {
1443     return D3D11_DECODE_IS_COMPARISON_FILTER(f);
1444 }
1445
1446 static enum wined3d_cmp_func wined3d_cmp_func_from_d3d11(D3D11_COMPARISON_FUNC f)
1447 {
1448     return (enum wined3d_cmp_func)f;
1449 }
1450
1451 static HRESULT d3d_sampler_state_init(struct d3d_sampler_state *state, struct d3d_device *device,
1452         const D3D11_SAMPLER_DESC *desc)
1453 {
1454     struct wined3d_sampler_desc wined3d_desc;
1455     HRESULT hr;
1456
1457     state->ID3D11SamplerState_iface.lpVtbl = &d3d11_sampler_state_vtbl;
1458     state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
1459     state->refcount = 1;
1460     wined3d_private_store_init(&state->private_store);
1461     state->desc = *desc;
1462
1463     wined3d_desc.address_u = wined3d_texture_address_from_d3d11(desc->AddressU);
1464     wined3d_desc.address_v = wined3d_texture_address_from_d3d11(desc->AddressV);
1465     wined3d_desc.address_w = wined3d_texture_address_from_d3d11(desc->AddressW);
1466     memcpy(wined3d_desc.border_color, desc->BorderColor, sizeof(wined3d_desc.border_color));
1467     wined3d_desc.mag_filter = wined3d_texture_filter_mag_from_d3d11(desc->Filter);
1468     wined3d_desc.min_filter = wined3d_texture_filter_min_from_d3d11(desc->Filter);
1469     wined3d_desc.mip_filter = wined3d_texture_filter_mip_from_d3d11(desc->Filter);
1470     wined3d_desc.lod_bias = desc->MipLODBias;
1471     wined3d_desc.min_lod = desc->MinLOD;
1472     wined3d_desc.max_lod = desc->MaxLOD;
1473     wined3d_desc.mip_base_level = 0;
1474     wined3d_desc.max_anisotropy = D3D11_DECODE_IS_ANISOTROPIC_FILTER(desc->Filter) ? desc->MaxAnisotropy : 1;
1475     wined3d_desc.compare = wined3d_texture_compare_from_d3d11(desc->Filter);
1476     wined3d_desc.comparison_func = wined3d_cmp_func_from_d3d11(desc->ComparisonFunc);
1477     wined3d_desc.srgb_decode = TRUE;
1478
1479     if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
1480     {
1481         ERR("Failed to insert sampler state entry.\n");
1482         wined3d_private_store_cleanup(&state->private_store);
1483         return E_FAIL;
1484     }
1485
1486     /* We cannot fail after creating a wined3d_sampler object. It would lead to
1487      * double free. */
1488     if (FAILED(hr = wined3d_sampler_create(device->wined3d_device, &wined3d_desc,
1489             state, &d3d_sampler_wined3d_parent_ops, &state->wined3d_sampler)))
1490     {
1491         WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
1492         wined3d_private_store_cleanup(&state->private_store);
1493         wine_rb_remove(&device->sampler_states, &state->entry);
1494         return hr;
1495     }
1496
1497     state->device = &device->ID3D11Device_iface;
1498     ID3D11Device_AddRef(state->device);
1499
1500     return S_OK;
1501 }
1502
1503 HRESULT d3d_sampler_state_create(struct d3d_device *device, const D3D11_SAMPLER_DESC *desc,
1504         struct d3d_sampler_state **state)
1505 {
1506     D3D11_SAMPLER_DESC normalized_desc;
1507     struct d3d_sampler_state *object;
1508     struct wine_rb_entry *entry;
1509     HRESULT hr;
1510
1511     if (!desc)
1512         return E_INVALIDARG;
1513
1514     normalized_desc = *desc;
1515     if (!D3D11_DECODE_IS_ANISOTROPIC_FILTER(normalized_desc.Filter))
1516         normalized_desc.MaxAnisotropy = 0;
1517     if (!D3D11_DECODE_IS_COMPARISON_FILTER(normalized_desc.Filter))
1518         normalized_desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
1519     if (normalized_desc.AddressU != D3D11_TEXTURE_ADDRESS_BORDER
1520             && normalized_desc.AddressV != D3D11_TEXTURE_ADDRESS_BORDER
1521             && normalized_desc.AddressW != D3D11_TEXTURE_ADDRESS_BORDER)
1522         memset(&normalized_desc.BorderColor, 0, sizeof(normalized_desc.BorderColor));
1523
1524     wined3d_mutex_lock();
1525     if ((entry = wine_rb_get(&device->sampler_states, &normalized_desc)))
1526     {
1527         object = WINE_RB_ENTRY_VALUE(entry, struct d3d_sampler_state, entry);
1528
1529         TRACE("Returning existing sampler state %p.\n", object);
1530         ID3D11SamplerState_AddRef(&object->ID3D11SamplerState_iface);
1531         *state = object;
1532         wined3d_mutex_unlock();
1533
1534         return S_OK;
1535     }
1536
1537     if (!(object = heap_alloc_zero(sizeof(*object))))
1538     {
1539         wined3d_mutex_unlock();
1540         return E_OUTOFMEMORY;
1541     }
1542
1543     hr = d3d_sampler_state_init(object, device, &normalized_desc);
1544     wined3d_mutex_unlock();
1545     if (FAILED(hr))
1546     {
1547         WARN("Failed to initialize sampler state, hr %#x.\n", hr);
1548         heap_free(object);
1549         return hr;
1550     }
1551
1552     TRACE("Created sampler state %p.\n", object);
1553     *state = object;
1554
1555     return S_OK;
1556 }
1557
1558 struct d3d_sampler_state *unsafe_impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
1559 {
1560     if (!iface)
1561         return NULL;
1562     assert(iface->lpVtbl == &d3d11_sampler_state_vtbl);
1563
1564     return impl_from_ID3D11SamplerState(iface);
1565 }
1566
1567 struct d3d_sampler_state *unsafe_impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1568 {
1569     if (!iface)
1570         return NULL;
1571     assert(iface->lpVtbl == &d3d10_sampler_state_vtbl);
1572
1573     return impl_from_ID3D10SamplerState(iface);
1574 }