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