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     return refcount;
  68 }
  69
  70 static ULONG STDMETHODCALLTYPE d3d11_blend_state_Release(ID3D11BlendState *iface)
  71 {
  72     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
  73     ULONG refcount = InterlockedDecrement(&state->refcount);
  74
  75     TRACE("%p decreasing refcount to %u.\n", state, refcount);
  76
  77     if (!refcount)
  78     {
  79         struct d3d_device *device = impl_from_ID3D11Device(state->device);
  80         wined3d_mutex_lock();
  81         wine_rb_remove(&device->blend_states, &state->entry);
  82         ID3D11Device_Release(state->device);
  83         wined3d_private_store_cleanup(&state->private_store);
  84         wined3d_mutex_unlock();
  85         HeapFree(GetProcessHeap(), 0, state);
  86     }
  87
  88     return refcount;
  89 }
  90
  91 static void STDMETHODCALLTYPE d3d11_blend_state_GetDevice(ID3D11BlendState *iface,
  92         ID3D11Device **device)
  93 {
  94     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
  95
  96     TRACE("iface %p, device %p.\n", iface, device);
  97
  98     *device = state->device;
  99     ID3D11Device_AddRef(*device);
 100 }
 101
 102 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_GetPrivateData(ID3D11BlendState *iface,
 103         REFGUID guid, UINT *data_size, void *data)
 104 {
 105     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 106
 107     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 108
 109     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 110 }
 111
 112 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_SetPrivateData(ID3D11BlendState *iface,
 113         REFGUID guid, UINT data_size, const void *data)
 114 {
 115     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 116
 117     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 118
 119     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 120 }
 121
 122 static HRESULT STDMETHODCALLTYPE d3d11_blend_state_SetPrivateDataInterface(ID3D11BlendState *iface,
 123         REFGUID guid, const IUnknown *data)
 124 {
 125     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 126
 127     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 128
 129     return d3d_set_private_data_interface(&state->private_store, guid, data);
 130 }
 131
 132 static void STDMETHODCALLTYPE d3d11_blend_state_GetDesc(ID3D11BlendState *iface, D3D11_BLEND_DESC *desc)
 133 {
 134     struct d3d_blend_state *state = impl_from_ID3D11BlendState(iface);
 135
 136     TRACE("iface %p, desc %p.\n", iface, desc);
 137
 138     *desc = state->desc;
 139 }
 140
 141 static const struct ID3D11BlendStateVtbl d3d11_blend_state_vtbl =
 142 {
 143     /* IUnknown methods */
 144     d3d11_blend_state_QueryInterface,
 145     d3d11_blend_state_AddRef,
 146     d3d11_blend_state_Release,
 147     /* ID3D11DeviceChild methods */
 148     d3d11_blend_state_GetDevice,
 149     d3d11_blend_state_GetPrivateData,
 150     d3d11_blend_state_SetPrivateData,
 151     d3d11_blend_state_SetPrivateDataInterface,
 152     /* ID3D11BlendState methods */
 153     d3d11_blend_state_GetDesc,
 154 };
 155
 156 /* ID3D10BlendState methods */
 157
 158 static inline struct d3d_blend_state *impl_from_ID3D10BlendState(ID3D10BlendState1 *iface)
 159 {
 160     return CONTAINING_RECORD(iface, struct d3d_blend_state, ID3D10BlendState1_iface);
 161 }
 162
 163 /* IUnknown methods */
 164
 165 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_QueryInterface(ID3D10BlendState1 *iface,
 166         REFIID riid, void **object)
 167 {
 168     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 169
 170     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 171
 172     return d3d11_blend_state_QueryInterface(&state->ID3D11BlendState_iface, riid, object);
 173 }
 174
 175 static ULONG STDMETHODCALLTYPE d3d10_blend_state_AddRef(ID3D10BlendState1 *iface)
 176 {
 177     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 178
 179     TRACE("iface %p.\n", iface);
 180
 181     return d3d11_blend_state_AddRef(&state->ID3D11BlendState_iface);
 182 }
 183
 184 static ULONG STDMETHODCALLTYPE d3d10_blend_state_Release(ID3D10BlendState1 *iface)
 185 {
 186     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 187
 188     TRACE("iface %p.\n", iface);
 189
 190     return d3d11_blend_state_Release(&state->ID3D11BlendState_iface);
 191 }
 192
 193 /* ID3D10DeviceChild methods */
 194
 195 static void STDMETHODCALLTYPE d3d10_blend_state_GetDevice(ID3D10BlendState1 *iface, ID3D10Device **device)
 196 {
 197     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 198
 199     TRACE("iface %p, device %p.\n", iface, device);
 200
 201     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 202 }
 203
 204 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_GetPrivateData(ID3D10BlendState1 *iface,
 205         REFGUID guid, UINT *data_size, void *data)
 206 {
 207     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 208
 209     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 210             iface, debugstr_guid(guid), data_size, data);
 211
 212     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 213 }
 214
 215 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateData(ID3D10BlendState1 *iface,
 216         REFGUID guid, UINT data_size, const void *data)
 217 {
 218     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 219
 220     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 221             iface, debugstr_guid(guid), data_size, data);
 222
 223     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 224 }
 225
 226 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateDataInterface(ID3D10BlendState1 *iface,
 227         REFGUID guid, const IUnknown *data)
 228 {
 229     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 230
 231     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 232
 233     return d3d_set_private_data_interface(&state->private_store, guid, data);
 234 }
 235
 236 /* ID3D10BlendState methods */
 237
 238 static void STDMETHODCALLTYPE d3d10_blend_state_GetDesc(ID3D10BlendState1 *iface, D3D10_BLEND_DESC *desc)
 239 {
 240     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 241     const D3D11_BLEND_DESC *d3d11_desc = &state->desc;
 242     unsigned int i;
 243
 244     TRACE("iface %p, desc %p.\n", iface, desc);
 245
 246     desc->AlphaToCoverageEnable = d3d11_desc->AlphaToCoverageEnable;
 247     desc->SrcBlend = d3d11_desc->RenderTarget[0].SrcBlend;
 248     desc->DestBlend = d3d11_desc->RenderTarget[0].DestBlend;
 249     desc->BlendOp = d3d11_desc->RenderTarget[0].BlendOp;
 250     desc->SrcBlendAlpha = d3d11_desc->RenderTarget[0].SrcBlendAlpha;
 251     desc->DestBlendAlpha = d3d11_desc->RenderTarget[0].DestBlendAlpha;
 252     desc->BlendOpAlpha = d3d11_desc->RenderTarget[0].BlendOpAlpha;
 253     for (i = 0; i < D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)
 254     {
 255         desc->BlendEnable[i] = d3d11_desc->RenderTarget[i].BlendEnable;
 256         desc->RenderTargetWriteMask[i] = d3d11_desc->RenderTarget[i].RenderTargetWriteMask;
 257     }
 258 }
 259
 260 static void STDMETHODCALLTYPE d3d10_blend_state_GetDesc1(ID3D10BlendState1 *iface, D3D10_BLEND_DESC1 *desc)
 261 {
 262     struct d3d_blend_state *state = impl_from_ID3D10BlendState(iface);
 263
 264     TRACE("iface %p, desc %p.\n", iface, desc);
 265
 266     memcpy(desc, &state->desc, sizeof(*desc));
 267 }
 268
 269 static const struct ID3D10BlendState1Vtbl d3d10_blend_state_vtbl =
 270 {
 271     /* IUnknown methods */
 272     d3d10_blend_state_QueryInterface,
 273     d3d10_blend_state_AddRef,
 274     d3d10_blend_state_Release,
 275     /* ID3D10DeviceChild methods */
 276     d3d10_blend_state_GetDevice,
 277     d3d10_blend_state_GetPrivateData,
 278     d3d10_blend_state_SetPrivateData,
 279     d3d10_blend_state_SetPrivateDataInterface,
 280     /* ID3D10BlendState methods */
 281     d3d10_blend_state_GetDesc,
 282     /* ID3D10BlendState1 methods */
 283     d3d10_blend_state_GetDesc1,
 284 };
 285
 286 HRESULT d3d_blend_state_init(struct d3d_blend_state *state, struct d3d_device *device,
 287         const D3D11_BLEND_DESC *desc)
 288 {
 289     state->ID3D11BlendState_iface.lpVtbl = &d3d11_blend_state_vtbl;
 290     state->ID3D10BlendState1_iface.lpVtbl = &d3d10_blend_state_vtbl;
 291     state->refcount = 1;
 292     wined3d_mutex_lock();
 293     wined3d_private_store_init(&state->private_store);
 294     state->desc = *desc;
 295
 296     if (wine_rb_put(&device->blend_states, desc, &state->entry) == -1)
 297     {
 298         ERR("Failed to insert blend state entry.\n");
 299         wined3d_private_store_cleanup(&state->private_store);
 300         wined3d_mutex_unlock();
 301         return E_FAIL;
 302     }
 303     wined3d_mutex_unlock();
 304
 305     state->device = &device->ID3D11Device_iface;
 306     ID3D11Device_AddRef(state->device);
 307
 308     return S_OK;
 309 }
 310
 311 struct d3d_blend_state *unsafe_impl_from_ID3D11BlendState(ID3D11BlendState *iface)
 312 {
 313     if (!iface)
 314         return NULL;
 315     assert(iface->lpVtbl == &d3d11_blend_state_vtbl);
 316
 317     return impl_from_ID3D11BlendState(iface);
 318 }
 319
 320 struct d3d_blend_state *unsafe_impl_from_ID3D10BlendState(ID3D10BlendState *iface)
 321 {
 322     if (!iface)
 323         return NULL;
 324     assert(iface->lpVtbl == (ID3D10BlendStateVtbl *)&d3d10_blend_state_vtbl);
 325
 326     return impl_from_ID3D10BlendState((ID3D10BlendState1 *)iface);
 327 }
 328
 329 /* ID3D11DepthStencilState methods */
 330
 331 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_QueryInterface(ID3D11DepthStencilState *iface,
 332         REFIID riid, void **object)
 333 {
 334     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 335
 336     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 337
 338     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilState)
 339             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 340             || IsEqualGUID(riid, &IID_IUnknown))
 341     {
 342         ID3D11DepthStencilState_AddRef(iface);
 343         *object = iface;
 344         return S_OK;
 345     }
 346
 347     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilState)
 348             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 349     {
 350         ID3D10DepthStencilState_AddRef(&state->ID3D10DepthStencilState_iface);
 351         *object = &state->ID3D10DepthStencilState_iface;
 352         return S_OK;
 353     }
 354
 355     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 356
 357     *object = NULL;
 358     return E_NOINTERFACE;
 359 }
 360
 361 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_state_AddRef(ID3D11DepthStencilState *iface)
 362 {
 363     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 364     ULONG refcount = InterlockedIncrement(&state->refcount);
 365
 366     TRACE("%p increasing refcount to %u.\n", state, refcount);
 367
 368     return refcount;
 369 }
 370
 371 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_state_Release(ID3D11DepthStencilState *iface)
 372 {
 373     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 374     ULONG refcount = InterlockedDecrement(&state->refcount);
 375
 376     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 377
 378     if (!refcount)
 379     {
 380         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 381         wined3d_mutex_lock();
 382         wine_rb_remove(&device->depthstencil_states, &state->entry);
 383         ID3D11Device_Release(state->device);
 384         wined3d_private_store_cleanup(&state->private_store);
 385         wined3d_mutex_unlock();
 386         HeapFree(GetProcessHeap(), 0, state);
 387     }
 388
 389     return refcount;
 390 }
 391
 392 static void STDMETHODCALLTYPE d3d11_depthstencil_state_GetDevice(ID3D11DepthStencilState *iface,
 393         ID3D11Device **device)
 394 {
 395     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 396
 397     TRACE("iface %p, device %p.\n", iface, device);
 398
 399     *device = state->device;
 400     ID3D11Device_AddRef(*device);
 401 }
 402
 403 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_GetPrivateData(ID3D11DepthStencilState *iface,
 404         REFGUID guid, UINT *data_size, void *data)
 405 {
 406     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 407
 408     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 409
 410     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 411 }
 412
 413 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_SetPrivateData(ID3D11DepthStencilState *iface,
 414         REFGUID guid, UINT data_size, const void *data)
 415 {
 416     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 417
 418     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 419
 420     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 421 }
 422
 423 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_state_SetPrivateDataInterface(ID3D11DepthStencilState *iface,
 424         REFGUID guid, const IUnknown *data)
 425 {
 426     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 427
 428     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 429
 430     return d3d_set_private_data_interface(&state->private_store, guid, data);
 431 }
 432
 433 static void STDMETHODCALLTYPE d3d11_depthstencil_state_GetDesc(ID3D11DepthStencilState *iface,
 434         D3D11_DEPTH_STENCIL_DESC *desc)
 435 {
 436     struct d3d_depthstencil_state *state = impl_from_ID3D11DepthStencilState(iface);
 437
 438     TRACE("iface %p, desc %p.\n", iface, desc);
 439
 440     *desc = state->desc;
 441 }
 442
 443 static const struct ID3D11DepthStencilStateVtbl d3d11_depthstencil_state_vtbl =
 444 {
 445     /* IUnknown methods */
 446     d3d11_depthstencil_state_QueryInterface,
 447     d3d11_depthstencil_state_AddRef,
 448     d3d11_depthstencil_state_Release,
 449     /* ID3D11DeviceChild methods */
 450     d3d11_depthstencil_state_GetDevice,
 451     d3d11_depthstencil_state_GetPrivateData,
 452     d3d11_depthstencil_state_SetPrivateData,
 453     d3d11_depthstencil_state_SetPrivateDataInterface,
 454     /* ID3D11DepthStencilState methods */
 455     d3d11_depthstencil_state_GetDesc,
 456 };
 457
 458 /* ID3D10DepthStencilState methods */
 459
 460 static inline struct d3d_depthstencil_state *impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 461 {
 462     return CONTAINING_RECORD(iface, struct d3d_depthstencil_state, ID3D10DepthStencilState_iface);
 463 }
 464
 465 /* IUnknown methods */
 466
 467 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_QueryInterface(ID3D10DepthStencilState *iface,
 468         REFIID riid, void **object)
 469 {
 470     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 471
 472     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 473
 474     return d3d11_depthstencil_state_QueryInterface(&state->ID3D11DepthStencilState_iface, riid, object);
 475 }
 476
 477 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_AddRef(ID3D10DepthStencilState *iface)
 478 {
 479     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 480
 481     TRACE("iface %p.\n", iface);
 482
 483     return d3d11_depthstencil_state_AddRef(&state->ID3D11DepthStencilState_iface);
 484 }
 485
 486 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_Release(ID3D10DepthStencilState *iface)
 487 {
 488     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 489
 490     TRACE("iface %p.\n", iface);
 491
 492     return d3d11_depthstencil_state_Release(&state->ID3D11DepthStencilState_iface);
 493 }
 494
 495 /* ID3D10DeviceChild methods */
 496
 497 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDevice(ID3D10DepthStencilState *iface, ID3D10Device **device)
 498 {
 499     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 500
 501     TRACE("iface %p, device %p.\n", iface, device);
 502
 503     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 504 }
 505
 506 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_GetPrivateData(ID3D10DepthStencilState *iface,
 507         REFGUID guid, UINT *data_size, void *data)
 508 {
 509     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 510
 511     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 512             iface, debugstr_guid(guid), data_size, data);
 513
 514     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 515 }
 516
 517 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateData(ID3D10DepthStencilState *iface,
 518         REFGUID guid, UINT data_size, const void *data)
 519 {
 520     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 521
 522     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 523             iface, debugstr_guid(guid), data_size, data);
 524
 525     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 526 }
 527
 528 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateDataInterface(ID3D10DepthStencilState *iface,
 529         REFGUID guid, const IUnknown *data)
 530 {
 531     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 532
 533     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 534
 535     return d3d_set_private_data_interface(&state->private_store, guid, data);
 536 }
 537
 538 /* ID3D10DepthStencilState methods */
 539
 540 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDesc(ID3D10DepthStencilState *iface,
 541         D3D10_DEPTH_STENCIL_DESC *desc)
 542 {
 543     struct d3d_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 544
 545     TRACE("iface %p, desc %p.\n", iface, desc);
 546
 547     memcpy(desc, &state->desc, sizeof(*desc));
 548 }
 549
 550 static const struct ID3D10DepthStencilStateVtbl d3d10_depthstencil_state_vtbl =
 551 {
 552     /* IUnknown methods */
 553     d3d10_depthstencil_state_QueryInterface,
 554     d3d10_depthstencil_state_AddRef,
 555     d3d10_depthstencil_state_Release,
 556     /* ID3D10DeviceChild methods */
 557     d3d10_depthstencil_state_GetDevice,
 558     d3d10_depthstencil_state_GetPrivateData,
 559     d3d10_depthstencil_state_SetPrivateData,
 560     d3d10_depthstencil_state_SetPrivateDataInterface,
 561     /* ID3D10DepthStencilState methods */
 562     d3d10_depthstencil_state_GetDesc,
 563 };
 564
 565 HRESULT d3d_depthstencil_state_init(struct d3d_depthstencil_state *state, struct d3d_device *device,
 566         const D3D11_DEPTH_STENCIL_DESC *desc)
 567 {
 568     state->ID3D11DepthStencilState_iface.lpVtbl = &d3d11_depthstencil_state_vtbl;
 569     state->ID3D10DepthStencilState_iface.lpVtbl = &d3d10_depthstencil_state_vtbl;
 570     state->refcount = 1;
 571     wined3d_mutex_lock();
 572     wined3d_private_store_init(&state->private_store);
 573     state->desc = *desc;
 574
 575     if (wine_rb_put(&device->depthstencil_states, desc, &state->entry) == -1)
 576     {
 577         ERR("Failed to insert depthstencil state entry.\n");
 578         wined3d_private_store_cleanup(&state->private_store);
 579         wined3d_mutex_unlock();
 580         return E_FAIL;
 581     }
 582     wined3d_mutex_unlock();
 583
 584     state->device = &device->ID3D11Device_iface;
 585     ID3D11Device_AddRef(state->device);
 586
 587     return S_OK;
 588 }
 589
 590 struct d3d_depthstencil_state *unsafe_impl_from_ID3D11DepthStencilState(ID3D11DepthStencilState *iface)
 591 {
 592     if (!iface)
 593         return NULL;
 594     assert(iface->lpVtbl == &d3d11_depthstencil_state_vtbl);
 595
 596     return impl_from_ID3D11DepthStencilState(iface);
 597 }
 598
 599 struct d3d_depthstencil_state *unsafe_impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 600 {
 601     if (!iface)
 602         return NULL;
 603     assert(iface->lpVtbl == &d3d10_depthstencil_state_vtbl);
 604
 605     return impl_from_ID3D10DepthStencilState(iface);
 606 }
 607
 608 /* ID3D11RasterizerState methods */
 609
 610 static inline struct d3d_rasterizer_state *impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
 611 {
 612     return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D11RasterizerState_iface);
 613 }
 614
 615 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11RasterizerState *iface,
 616         REFIID riid, void **object)
 617 {
 618     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 619
 620     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 621
 622     if (IsEqualGUID(riid, &IID_ID3D11RasterizerState)
 623             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 624             || IsEqualGUID(riid, &IID_IUnknown))
 625     {
 626         ID3D11RasterizerState_AddRef(iface);
 627         *object = iface;
 628         return S_OK;
 629     }
 630
 631     if (IsEqualGUID(riid, &IID_ID3D10RasterizerState)
 632             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 633     {
 634         ID3D10RasterizerState_AddRef(&state->ID3D10RasterizerState_iface);
 635         *object = &state->ID3D10RasterizerState_iface;
 636         return S_OK;
 637     }
 638
 639     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 640
 641     *object = NULL;
 642     return E_NOINTERFACE;
 643 }
 644
 645 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerState *iface)
 646 {
 647     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 648     ULONG refcount = InterlockedIncrement(&state->refcount);
 649
 650     TRACE("%p increasing refcount to %u.\n", state, refcount);
 651
 652     return refcount;
 653 }
 654
 655 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerState *iface)
 656 {
 657     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 658     ULONG refcount = InterlockedDecrement(&state->refcount);
 659
 660     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 661
 662     if (!refcount)
 663     {
 664         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 665         wined3d_mutex_lock();
 666         wine_rb_remove(&device->rasterizer_states, &state->entry);
 667         wined3d_rasterizer_state_decref(state->wined3d_state);
 668         wined3d_private_store_cleanup(&state->private_store);
 669         wined3d_mutex_unlock();
 670         ID3D11Device_Release(state->device);
 671         HeapFree(GetProcessHeap(), 0, state);
 672     }
 673
 674     return refcount;
 675 }
 676
 677 static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDevice(ID3D11RasterizerState *iface,
 678         ID3D11Device **device)
 679 {
 680     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 681
 682     TRACE("iface %p, device %p.\n", iface, device);
 683
 684     *device = state->device;
 685     ID3D11Device_AddRef(*device);
 686 }
 687
 688 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_GetPrivateData(ID3D11RasterizerState *iface,
 689         REFGUID guid, UINT *data_size, void *data)
 690 {
 691     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 692
 693     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 694
 695     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 696 }
 697
 698 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateData(ID3D11RasterizerState *iface,
 699         REFGUID guid, UINT data_size, const void *data)
 700 {
 701     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 702
 703     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 704
 705     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 706 }
 707
 708 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_SetPrivateDataInterface(ID3D11RasterizerState *iface,
 709         REFGUID guid, const IUnknown *data)
 710 {
 711     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 712
 713     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 714
 715     return d3d_set_private_data_interface(&state->private_store, guid, data);
 716 }
 717
 718 static void STDMETHODCALLTYPE d3d11_rasterizer_state_GetDesc(ID3D11RasterizerState *iface,
 719         D3D11_RASTERIZER_DESC *desc)
 720 {
 721     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 722
 723     TRACE("iface %p, desc %p.\n", iface, desc);
 724
 725     *desc = state->desc;
 726 }
 727
 728 static const struct ID3D11RasterizerStateVtbl d3d11_rasterizer_state_vtbl =
 729 {
 730     /* IUnknown methods */
 731     d3d11_rasterizer_state_QueryInterface,
 732     d3d11_rasterizer_state_AddRef,
 733     d3d11_rasterizer_state_Release,
 734     /* ID3D11DeviceChild methods */
 735     d3d11_rasterizer_state_GetDevice,
 736     d3d11_rasterizer_state_GetPrivateData,
 737     d3d11_rasterizer_state_SetPrivateData,
 738     d3d11_rasterizer_state_SetPrivateDataInterface,
 739     /* ID3D11RasterizerState methods */
 740     d3d11_rasterizer_state_GetDesc,
 741 };
 742
 743 /* ID3D10RasterizerState methods */
 744
 745 static inline struct d3d_rasterizer_state *impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 746 {
 747     return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D10RasterizerState_iface);
 748 }
 749
 750 /* IUnknown methods */
 751
 752 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_QueryInterface(ID3D10RasterizerState *iface,
 753         REFIID riid, void **object)
 754 {
 755     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 756
 757     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 758
 759     return d3d11_rasterizer_state_QueryInterface(&state->ID3D11RasterizerState_iface, riid, object);
 760 }
 761
 762 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_AddRef(ID3D10RasterizerState *iface)
 763 {
 764     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 765
 766     TRACE("iface %p.\n", iface);
 767
 768     return d3d11_rasterizer_state_AddRef(&state->ID3D11RasterizerState_iface);
 769 }
 770
 771 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_Release(ID3D10RasterizerState *iface)
 772 {
 773     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 774
 775     TRACE("iface %p.\n", state);
 776
 777     return d3d11_rasterizer_state_Release(&state->ID3D11RasterizerState_iface);
 778 }
 779
 780 /* ID3D10DeviceChild methods */
 781
 782 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDevice(ID3D10RasterizerState *iface, ID3D10Device **device)
 783 {
 784     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 785
 786     TRACE("iface %p, device %p.\n", iface, device);
 787
 788     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
 789 }
 790
 791 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_GetPrivateData(ID3D10RasterizerState *iface,
 792         REFGUID guid, UINT *data_size, void *data)
 793 {
 794     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 795
 796     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 797             iface, debugstr_guid(guid), data_size, data);
 798
 799     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 800 }
 801
 802 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateData(ID3D10RasterizerState *iface,
 803         REFGUID guid, UINT data_size, const void *data)
 804 {
 805     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 806
 807     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 808             iface, debugstr_guid(guid), data_size, data);
 809
 810     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 811 }
 812
 813 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateDataInterface(ID3D10RasterizerState *iface,
 814         REFGUID guid, const IUnknown *data)
 815 {
 816     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 817
 818     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 819
 820     return d3d_set_private_data_interface(&state->private_store, guid, data);
 821 }
 822
 823 /* ID3D10RasterizerState methods */
 824
 825 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDesc(ID3D10RasterizerState *iface,
 826         D3D10_RASTERIZER_DESC *desc)
 827 {
 828     struct d3d_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 829
 830     TRACE("iface %p, desc %p.\n", iface, desc);
 831
 832     memcpy(desc, &state->desc, sizeof(*desc));
 833 }
 834
 835 static const struct ID3D10RasterizerStateVtbl d3d10_rasterizer_state_vtbl =
 836 {
 837     /* IUnknown methods */
 838     d3d10_rasterizer_state_QueryInterface,
 839     d3d10_rasterizer_state_AddRef,
 840     d3d10_rasterizer_state_Release,
 841     /* ID3D10DeviceChild methods */
 842     d3d10_rasterizer_state_GetDevice,
 843     d3d10_rasterizer_state_GetPrivateData,
 844     d3d10_rasterizer_state_SetPrivateData,
 845     d3d10_rasterizer_state_SetPrivateDataInterface,
 846     /* ID3D10RasterizerState methods */
 847     d3d10_rasterizer_state_GetDesc,
 848 };
 849
 850 HRESULT d3d_rasterizer_state_init(struct d3d_rasterizer_state *state, struct d3d_device *device,
 851         const D3D11_RASTERIZER_DESC *desc)
 852 {
 853     struct wined3d_rasterizer_state_desc wined3d_desc;
 854     HRESULT hr;
 855
 856     state->ID3D11RasterizerState_iface.lpVtbl = &d3d11_rasterizer_state_vtbl;
 857     state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
 858     state->refcount = 1;
 859     wined3d_mutex_lock();
 860     wined3d_private_store_init(&state->private_store);
 861     state->desc = *desc;
 862
 863     wined3d_desc.front_ccw = desc->FrontCounterClockwise;
 864     if (FAILED(hr = wined3d_rasterizer_state_create(device->wined3d_device,
 865             &wined3d_desc, &state->wined3d_state)))
 866     {
 867         WARN("Failed to create wined3d rasterizer state, hr %#x.\n", hr);
 868         wined3d_private_store_cleanup(&state->private_store);
 869         wined3d_mutex_unlock();
 870         return hr;
 871     }
 872
 873     if (wine_rb_put(&device->rasterizer_states, desc, &state->entry) == -1)
 874     {
 875         ERR("Failed to insert rasterizer state entry.\n");
 876         wined3d_private_store_cleanup(&state->private_store);
 877         wined3d_rasterizer_state_decref(state->wined3d_state);
 878         wined3d_mutex_unlock();
 879         return E_FAIL;
 880     }
 881     wined3d_mutex_unlock();
 882
 883     ID3D11Device_AddRef(state->device = &device->ID3D11Device_iface);
 884
 885     return S_OK;
 886 }
 887
 888 struct d3d_rasterizer_state *unsafe_impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
 889 {
 890     if (!iface)
 891         return NULL;
 892     assert(iface->lpVtbl == &d3d11_rasterizer_state_vtbl);
 893
 894     return impl_from_ID3D11RasterizerState(iface);
 895 }
 896
 897 struct d3d_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 898 {
 899     if (!iface)
 900         return NULL;
 901     assert(iface->lpVtbl == &d3d10_rasterizer_state_vtbl);
 902
 903     return impl_from_ID3D10RasterizerState(iface);
 904 }
 905
 906 /* ID3D11SampleState methods */
 907
 908 static inline struct d3d_sampler_state *impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
 909 {
 910     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D11SamplerState_iface);
 911 }
 912
 913 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_QueryInterface(ID3D11SamplerState *iface,
 914         REFIID riid, void **object)
 915 {
 916     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 917
 918     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 919
 920     if (IsEqualGUID(riid, &IID_ID3D11SamplerState)
 921             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 922             || IsEqualGUID(riid, &IID_IUnknown))
 923     {
 924         ID3D11SamplerState_AddRef(iface);
 925         *object = iface;
 926         return S_OK;
 927     }
 928
 929     if (IsEqualGUID(riid, &IID_ID3D10SamplerState)
 930             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 931     {
 932         ID3D10SamplerState_AddRef(&state->ID3D10SamplerState_iface);
 933         *object = &state->ID3D10SamplerState_iface;
 934         return S_OK;
 935     }
 936
 937     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 938
 939     *object = NULL;
 940     return E_NOINTERFACE;
 941 }
 942
 943 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_AddRef(ID3D11SamplerState *iface)
 944 {
 945     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 946     ULONG refcount = InterlockedIncrement(&state->refcount);
 947
 948     TRACE("%p increasing refcount to %u.\n", state, refcount);
 949
 950     return refcount;
 951 }
 952
 953 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_Release(ID3D11SamplerState *iface)
 954 {
 955     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 956     ULONG refcount = InterlockedDecrement(&state->refcount);
 957
 958     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 959
 960     if (!refcount)
 961     {
 962         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 963
 964         wined3d_mutex_lock();
 965         wined3d_sampler_decref(state->wined3d_sampler);
 966         wine_rb_remove(&device->sampler_states, &state->entry);
 967         ID3D11Device_Release(state->device);
 968         wined3d_private_store_cleanup(&state->private_store);
 969         wined3d_mutex_unlock();
 970         HeapFree(GetProcessHeap(), 0, state);
 971     }
 972
 973     return refcount;
 974 }
 975
 976 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDevice(ID3D11SamplerState *iface,
 977         ID3D11Device **device)
 978 {
 979     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 980
 981     TRACE("iface %p, device %p.\n", iface, device);
 982
 983     *device = state->device;
 984     ID3D11Device_AddRef(*device);
 985 }
 986
 987 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_GetPrivateData(ID3D11SamplerState *iface,
 988         REFGUID guid, UINT *data_size, void *data)
 989 {
 990     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 991
 992     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 993
 994     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 995 }
 996
 997 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateData(ID3D11SamplerState *iface,
 998         REFGUID guid, UINT data_size, const void *data)
 999 {
1000     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1001
1002     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1003
1004     return d3d_set_private_data(&state->private_store, guid, data_size, data);
1005 }
1006
1007 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateDataInterface(ID3D11SamplerState *iface,
1008         REFGUID guid, const IUnknown *data)
1009 {
1010     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1011
1012     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1013
1014     return d3d_set_private_data_interface(&state->private_store, guid, data);
1015 }
1016
1017 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDesc(ID3D11SamplerState *iface,
1018         D3D11_SAMPLER_DESC *desc)
1019 {
1020     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1021
1022     TRACE("iface %p, desc %p.\n", iface, desc);
1023
1024     *desc = state->desc;
1025 }
1026
1027 static const struct ID3D11SamplerStateVtbl d3d11_sampler_state_vtbl =
1028 {
1029     /* IUnknown methods */
1030     d3d11_sampler_state_QueryInterface,
1031     d3d11_sampler_state_AddRef,
1032     d3d11_sampler_state_Release,
1033     /* ID3D11DeviceChild methods */
1034     d3d11_sampler_state_GetDevice,
1035     d3d11_sampler_state_GetPrivateData,
1036     d3d11_sampler_state_SetPrivateData,
1037     d3d11_sampler_state_SetPrivateDataInterface,
1038     /* ID3D11SamplerState methods */
1039     d3d11_sampler_state_GetDesc,
1040 };
1041
1042 /* ID3D10SamplerState methods */
1043
1044 static inline struct d3d_sampler_state *impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1045 {
1046     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D10SamplerState_iface);
1047 }
1048
1049 /* IUnknown methods */
1050
1051 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_QueryInterface(ID3D10SamplerState *iface,
1052         REFIID riid, void **object)
1053 {
1054     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1055
1056     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1057
1058     return d3d11_sampler_state_QueryInterface(&state->ID3D11SamplerState_iface, riid, object);
1059 }
1060
1061 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_AddRef(ID3D10SamplerState *iface)
1062 {
1063     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1064
1065     TRACE("iface %p.\n", iface);
1066
1067     return d3d11_sampler_state_AddRef(&state->ID3D11SamplerState_iface);
1068 }
1069
1070 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_Release(ID3D10SamplerState *iface)
1071 {
1072     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1073
1074     TRACE("iface %p.\n", iface);
1075
1076     return d3d11_sampler_state_Release(&state->ID3D11SamplerState_iface);
1077 }
1078
1079 /* ID3D10DeviceChild methods */
1080
1081 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDevice(ID3D10SamplerState *iface, ID3D10Device **device)
1082 {
1083     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1084
1085     TRACE("iface %p, device %p.\n", iface, device);
1086
1087     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
1088 }
1089
1090 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_GetPrivateData(ID3D10SamplerState *iface,
1091         REFGUID guid, UINT *data_size, void *data)
1092 {
1093     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1094
1095     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1096             iface, debugstr_guid(guid), data_size, data);
1097
1098     return d3d_get_private_data(&state->private_store, guid, data_size, data);
1099 }
1100
1101 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateData(ID3D10SamplerState *iface,
1102         REFGUID guid, UINT data_size, const void *data)
1103 {
1104     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1105
1106     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1107             iface, debugstr_guid(guid), data_size, data);
1108
1109     return d3d_set_private_data(&state->private_store, guid, data_size, data);
1110 }
1111
1112 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateDataInterface(ID3D10SamplerState *iface,
1113         REFGUID guid, const IUnknown *data)
1114 {
1115     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1116
1117     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1118
1119     return d3d_set_private_data_interface(&state->private_store, guid, data);
1120 }
1121
1122 /* ID3D10SamplerState methods */
1123
1124 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDesc(ID3D10SamplerState *iface,
1125         D3D10_SAMPLER_DESC *desc)
1126 {
1127     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1128
1129     TRACE("iface %p, desc %p.\n", iface, desc);
1130
1131     memcpy(desc, &state->desc, sizeof(*desc));
1132 }
1133
1134 static const struct ID3D10SamplerStateVtbl d3d10_sampler_state_vtbl =
1135 {
1136     /* IUnknown methods */
1137     d3d10_sampler_state_QueryInterface,
1138     d3d10_sampler_state_AddRef,
1139     d3d10_sampler_state_Release,
1140     /* ID3D10DeviceChild methods */
1141     d3d10_sampler_state_GetDevice,
1142     d3d10_sampler_state_GetPrivateData,
1143     d3d10_sampler_state_SetPrivateData,
1144     d3d10_sampler_state_SetPrivateDataInterface,
1145     /* ID3D10SamplerState methods */
1146     d3d10_sampler_state_GetDesc,
1147 };
1148
1149 static enum wined3d_texture_address wined3d_texture_address_from_d3d11(enum D3D11_TEXTURE_ADDRESS_MODE t)
1150 {
1151     return (enum wined3d_texture_address)t;
1152 }
1153
1154 static enum wined3d_texture_filter_type wined3d_texture_filter_mip_from_d3d11(enum D3D11_FILTER f)
1155 {
1156     if (D3D11_DECODE_MIP_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1157         return WINED3D_TEXF_LINEAR;
1158     return WINED3D_TEXF_POINT;
1159 }
1160
1161 static enum wined3d_texture_filter_type wined3d_texture_filter_mag_from_d3d11(enum D3D11_FILTER f)
1162 {
1163     if (D3D11_DECODE_MAG_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1164         return WINED3D_TEXF_LINEAR;
1165     return WINED3D_TEXF_POINT;
1166 }
1167
1168 static enum wined3d_texture_filter_type wined3d_texture_filter_min_from_d3d11(enum D3D11_FILTER f)
1169 {
1170     if (D3D11_DECODE_MIN_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1171         return WINED3D_TEXF_LINEAR;
1172     return WINED3D_TEXF_POINT;
1173 }
1174
1175 static BOOL wined3d_texture_compare_from_d3d11(enum D3D11_FILTER f)
1176 {
1177     return D3D11_DECODE_IS_COMPARISON_FILTER(f);
1178 }
1179
1180 static enum wined3d_cmp_func wined3d_cmp_func_from_d3d11(D3D11_COMPARISON_FUNC f)
1181 {
1182     return (enum wined3d_cmp_func)f;
1183 }
1184
1185 HRESULT d3d_sampler_state_init(struct d3d_sampler_state *state, struct d3d_device *device,
1186         const D3D11_SAMPLER_DESC *desc)
1187 {
1188     struct wined3d_sampler_desc wined3d_desc;
1189     HRESULT hr;
1190
1191     state->ID3D11SamplerState_iface.lpVtbl = &d3d11_sampler_state_vtbl;
1192     state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
1193     state->refcount = 1;
1194     wined3d_mutex_lock();
1195     wined3d_private_store_init(&state->private_store);
1196     state->desc = *desc;
1197
1198     wined3d_desc.address_u = wined3d_texture_address_from_d3d11(desc->AddressU);
1199     wined3d_desc.address_v = wined3d_texture_address_from_d3d11(desc->AddressV);
1200     wined3d_desc.address_w = wined3d_texture_address_from_d3d11(desc->AddressW);
1201     memcpy(wined3d_desc.border_color, desc->BorderColor, sizeof(wined3d_desc.border_color));
1202     wined3d_desc.mag_filter = wined3d_texture_filter_mag_from_d3d11(desc->Filter);
1203     wined3d_desc.min_filter = wined3d_texture_filter_min_from_d3d11(desc->Filter);
1204     wined3d_desc.mip_filter = wined3d_texture_filter_mip_from_d3d11(desc->Filter);
1205     wined3d_desc.lod_bias = desc->MipLODBias;
1206     wined3d_desc.min_lod = desc->MinLOD;
1207     wined3d_desc.max_lod = desc->MaxLOD;
1208     wined3d_desc.mip_base_level = 0;
1209     wined3d_desc.max_anisotropy = D3D11_DECODE_IS_ANISOTROPIC_FILTER(desc->Filter) ? desc->MaxAnisotropy : 1;
1210     wined3d_desc.compare = wined3d_texture_compare_from_d3d11(desc->Filter);
1211     wined3d_desc.comparison_func = wined3d_cmp_func_from_d3d11(desc->ComparisonFunc);
1212     wined3d_desc.srgb_decode = TRUE;
1213
1214     if (FAILED(hr = wined3d_sampler_create(device->wined3d_device, &wined3d_desc, state, &state->wined3d_sampler)))
1215     {
1216         WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
1217         wined3d_private_store_cleanup(&state->private_store);
1218         wined3d_mutex_unlock();
1219         return hr;
1220     }
1221
1222     if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
1223     {
1224         ERR("Failed to insert sampler state entry.\n");
1225         wined3d_sampler_decref(state->wined3d_sampler);
1226         wined3d_private_store_cleanup(&state->private_store);
1227         wined3d_mutex_unlock();
1228         return E_FAIL;
1229     }
1230     wined3d_mutex_unlock();
1231
1232     state->device = &device->ID3D11Device_iface;
1233     ID3D11Device_AddRef(state->device);
1234
1235     return S_OK;
1236 }
1237
1238 struct d3d_sampler_state *unsafe_impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
1239 {
1240     if (!iface)
1241         return NULL;
1242     assert(iface->lpVtbl == &d3d11_sampler_state_vtbl);
1243
1244     return impl_from_ID3D11SamplerState(iface);
1245 }
1246
1247 struct d3d_sampler_state *unsafe_impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1248 {
1249     if (!iface)
1250         return NULL;
1251     assert(iface->lpVtbl == &d3d10_sampler_state_vtbl);
1252
1253     return impl_from_ID3D10SamplerState(iface);
1254 }