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