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_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 601 {
 602     if (!iface)
 603         return NULL;
 604     assert(iface->lpVtbl == &d3d10_depthstencil_state_vtbl);
 605
 606     return impl_from_ID3D10DepthStencilState(iface);
 607 }
 608
 609 /* ID3D11RasterizerState methods */
 610
 611 static inline struct d3d_rasterizer_state *impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
 612 {
 613     return CONTAINING_RECORD(iface, struct d3d_rasterizer_state, ID3D11RasterizerState_iface);
 614 }
 615
 616 static HRESULT STDMETHODCALLTYPE d3d11_rasterizer_state_QueryInterface(ID3D11RasterizerState *iface,
 617         REFIID riid, void **object)
 618 {
 619     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 620
 621     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 622
 623     if (IsEqualGUID(riid, &IID_ID3D11RasterizerState)
 624             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 625             || IsEqualGUID(riid, &IID_IUnknown))
 626     {
 627         ID3D11RasterizerState_AddRef(iface);
 628         *object = iface;
 629         return S_OK;
 630     }
 631
 632     if (IsEqualGUID(riid, &IID_ID3D10RasterizerState)
 633             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 634     {
 635         ID3D10RasterizerState_AddRef(&state->ID3D10RasterizerState_iface);
 636         *object = &state->ID3D10RasterizerState_iface;
 637         return S_OK;
 638     }
 639
 640     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 641
 642     *object = NULL;
 643     return E_NOINTERFACE;
 644 }
 645
 646 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_AddRef(ID3D11RasterizerState *iface)
 647 {
 648     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 649     ULONG refcount = InterlockedIncrement(&state->refcount);
 650
 651     TRACE("%p increasing refcount to %u.\n", state, refcount);
 652
 653     return refcount;
 654 }
 655
 656 static ULONG STDMETHODCALLTYPE d3d11_rasterizer_state_Release(ID3D11RasterizerState *iface)
 657 {
 658     struct d3d_rasterizer_state *state = impl_from_ID3D11RasterizerState(iface);
 659     ULONG refcount = InterlockedDecrement(&state->refcount);
 660
 661     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 662
 663     if (!refcount)
 664     {
 665         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 666         wined3d_mutex_lock();
 667         wine_rb_remove(&device->rasterizer_states, &state->desc);
 668         ID3D11Device_Release(state->device);
 669         wined3d_private_store_cleanup(&state->private_store);
 670         wined3d_mutex_unlock();
 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     state->ID3D11RasterizerState_iface.lpVtbl = &d3d11_rasterizer_state_vtbl;
 854     state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
 855     state->refcount = 1;
 856     wined3d_mutex_lock();
 857     wined3d_private_store_init(&state->private_store);
 858     state->desc = *desc;
 859
 860     if (wine_rb_put(&device->rasterizer_states, desc, &state->entry) == -1)
 861     {
 862         ERR("Failed to insert rasterizer state entry.\n");
 863         wined3d_private_store_cleanup(&state->private_store);
 864         wined3d_mutex_unlock();
 865         return E_FAIL;
 866     }
 867     wined3d_mutex_unlock();
 868
 869     state->device = &device->ID3D11Device_iface;
 870     ID3D11Device_AddRef(state->device);
 871
 872     return S_OK;
 873 }
 874
 875 struct d3d_rasterizer_state *unsafe_impl_from_ID3D11RasterizerState(ID3D11RasterizerState *iface)
 876 {
 877     if (!iface)
 878         return NULL;
 879     assert(iface->lpVtbl == &d3d11_rasterizer_state_vtbl);
 880
 881     return impl_from_ID3D11RasterizerState(iface);
 882 }
 883
 884 struct d3d_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 885 {
 886     if (!iface)
 887         return NULL;
 888     assert(iface->lpVtbl == &d3d10_rasterizer_state_vtbl);
 889
 890     return impl_from_ID3D10RasterizerState(iface);
 891 }
 892
 893 /* ID3D11SampleState methods */
 894
 895 static inline struct d3d_sampler_state *impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
 896 {
 897     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D11SamplerState_iface);
 898 }
 899
 900 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_QueryInterface(ID3D11SamplerState *iface,
 901         REFIID riid, void **object)
 902 {
 903     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 904
 905     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 906
 907     if (IsEqualGUID(riid, &IID_ID3D11SamplerState)
 908             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 909             || IsEqualGUID(riid, &IID_IUnknown))
 910     {
 911         ID3D11SamplerState_AddRef(iface);
 912         *object = iface;
 913         return S_OK;
 914     }
 915
 916     if (IsEqualGUID(riid, &IID_ID3D10SamplerState)
 917             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 918     {
 919         ID3D10SamplerState_AddRef(&state->ID3D10SamplerState_iface);
 920         *object = &state->ID3D10SamplerState_iface;
 921         return S_OK;
 922     }
 923
 924     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 925
 926     *object = NULL;
 927     return E_NOINTERFACE;
 928 }
 929
 930 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_AddRef(ID3D11SamplerState *iface)
 931 {
 932     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 933     ULONG refcount = InterlockedIncrement(&state->refcount);
 934
 935     TRACE("%p increasing refcount to %u.\n", state, refcount);
 936
 937     return refcount;
 938 }
 939
 940 static ULONG STDMETHODCALLTYPE d3d11_sampler_state_Release(ID3D11SamplerState *iface)
 941 {
 942     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 943     ULONG refcount = InterlockedDecrement(&state->refcount);
 944
 945     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 946
 947     if (!refcount)
 948     {
 949         struct d3d_device *device = impl_from_ID3D11Device(state->device);
 950
 951         wined3d_mutex_lock();
 952         wined3d_sampler_decref(state->wined3d_sampler);
 953         wine_rb_remove(&device->sampler_states, &state->desc);
 954         ID3D11Device_Release(state->device);
 955         wined3d_private_store_cleanup(&state->private_store);
 956         wined3d_mutex_unlock();
 957         HeapFree(GetProcessHeap(), 0, state);
 958     }
 959
 960     return refcount;
 961 }
 962
 963 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDevice(ID3D11SamplerState *iface,
 964         ID3D11Device **device)
 965 {
 966     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 967
 968     TRACE("iface %p, device %p.\n", iface, device);
 969
 970     *device = state->device;
 971     ID3D11Device_AddRef(*device);
 972 }
 973
 974 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_GetPrivateData(ID3D11SamplerState *iface,
 975         REFGUID guid, UINT *data_size, void *data)
 976 {
 977     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 978
 979     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 980
 981     return d3d_get_private_data(&state->private_store, guid, data_size, data);
 982 }
 983
 984 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateData(ID3D11SamplerState *iface,
 985         REFGUID guid, UINT data_size, const void *data)
 986 {
 987     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 988
 989     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 990
 991     return d3d_set_private_data(&state->private_store, guid, data_size, data);
 992 }
 993
 994 static HRESULT STDMETHODCALLTYPE d3d11_sampler_state_SetPrivateDataInterface(ID3D11SamplerState *iface,
 995         REFGUID guid, const IUnknown *data)
 996 {
 997     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
 998
 999     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1000
1001     return d3d_set_private_data_interface(&state->private_store, guid, data);
1002 }
1003
1004 static void STDMETHODCALLTYPE d3d11_sampler_state_GetDesc(ID3D11SamplerState *iface,
1005         D3D11_SAMPLER_DESC *desc)
1006 {
1007     struct d3d_sampler_state *state = impl_from_ID3D11SamplerState(iface);
1008
1009     TRACE("iface %p, desc %p.\n", iface, desc);
1010
1011     *desc = state->desc;
1012 }
1013
1014 static const struct ID3D11SamplerStateVtbl d3d11_sampler_state_vtbl =
1015 {
1016     /* IUnknown methods */
1017     d3d11_sampler_state_QueryInterface,
1018     d3d11_sampler_state_AddRef,
1019     d3d11_sampler_state_Release,
1020     /* ID3D11DeviceChild methods */
1021     d3d11_sampler_state_GetDevice,
1022     d3d11_sampler_state_GetPrivateData,
1023     d3d11_sampler_state_SetPrivateData,
1024     d3d11_sampler_state_SetPrivateDataInterface,
1025     /* ID3D11SamplerState methods */
1026     d3d11_sampler_state_GetDesc,
1027 };
1028
1029 /* ID3D10SamplerState methods */
1030
1031 static inline struct d3d_sampler_state *impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1032 {
1033     return CONTAINING_RECORD(iface, struct d3d_sampler_state, ID3D10SamplerState_iface);
1034 }
1035
1036 /* IUnknown methods */
1037
1038 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_QueryInterface(ID3D10SamplerState *iface,
1039         REFIID riid, void **object)
1040 {
1041     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1042
1043     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1044
1045     return d3d11_sampler_state_QueryInterface(&state->ID3D11SamplerState_iface, riid, object);
1046 }
1047
1048 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_AddRef(ID3D10SamplerState *iface)
1049 {
1050     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1051
1052     TRACE("iface %p.\n", iface);
1053
1054     return d3d11_sampler_state_AddRef(&state->ID3D11SamplerState_iface);
1055 }
1056
1057 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_Release(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_Release(&state->ID3D11SamplerState_iface);
1064 }
1065
1066 /* ID3D10DeviceChild methods */
1067
1068 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDevice(ID3D10SamplerState *iface, ID3D10Device **device)
1069 {
1070     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1071
1072     TRACE("iface %p, device %p.\n", iface, device);
1073
1074     ID3D11Device_QueryInterface(state->device, &IID_ID3D10Device, (void **)device);
1075 }
1076
1077 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_GetPrivateData(ID3D10SamplerState *iface,
1078         REFGUID guid, UINT *data_size, void *data)
1079 {
1080     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1081
1082     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1083             iface, debugstr_guid(guid), data_size, data);
1084
1085     return d3d_get_private_data(&state->private_store, guid, data_size, data);
1086 }
1087
1088 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateData(ID3D10SamplerState *iface,
1089         REFGUID guid, UINT data_size, const void *data)
1090 {
1091     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1092
1093     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1094             iface, debugstr_guid(guid), data_size, data);
1095
1096     return d3d_set_private_data(&state->private_store, guid, data_size, data);
1097 }
1098
1099 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateDataInterface(ID3D10SamplerState *iface,
1100         REFGUID guid, const IUnknown *data)
1101 {
1102     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1103
1104     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1105
1106     return d3d_set_private_data_interface(&state->private_store, guid, data);
1107 }
1108
1109 /* ID3D10SamplerState methods */
1110
1111 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDesc(ID3D10SamplerState *iface,
1112         D3D10_SAMPLER_DESC *desc)
1113 {
1114     struct d3d_sampler_state *state = impl_from_ID3D10SamplerState(iface);
1115
1116     TRACE("iface %p, desc %p.\n", iface, desc);
1117
1118     memcpy(desc, &state->desc, sizeof(*desc));
1119 }
1120
1121 static const struct ID3D10SamplerStateVtbl d3d10_sampler_state_vtbl =
1122 {
1123     /* IUnknown methods */
1124     d3d10_sampler_state_QueryInterface,
1125     d3d10_sampler_state_AddRef,
1126     d3d10_sampler_state_Release,
1127     /* ID3D10DeviceChild methods */
1128     d3d10_sampler_state_GetDevice,
1129     d3d10_sampler_state_GetPrivateData,
1130     d3d10_sampler_state_SetPrivateData,
1131     d3d10_sampler_state_SetPrivateDataInterface,
1132     /* ID3D10SamplerState methods */
1133     d3d10_sampler_state_GetDesc,
1134 };
1135
1136 static enum wined3d_texture_address wined3d_texture_address_from_d3d11(enum D3D11_TEXTURE_ADDRESS_MODE t)
1137 {
1138     return (enum wined3d_texture_address)t;
1139 }
1140
1141 static enum wined3d_texture_filter_type wined3d_texture_filter_mip_from_d3d11(enum D3D11_FILTER f)
1142 {
1143     if (D3D11_DECODE_MIP_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1144         return WINED3D_TEXF_LINEAR;
1145     return WINED3D_TEXF_POINT;
1146 }
1147
1148 static enum wined3d_texture_filter_type wined3d_texture_filter_mag_from_d3d11(enum D3D11_FILTER f)
1149 {
1150     if (D3D11_DECODE_MAG_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1151         return WINED3D_TEXF_LINEAR;
1152     return WINED3D_TEXF_POINT;
1153 }
1154
1155 static enum wined3d_texture_filter_type wined3d_texture_filter_min_from_d3d11(enum D3D11_FILTER f)
1156 {
1157     if (D3D11_DECODE_MIN_FILTER(f) == D3D11_FILTER_TYPE_LINEAR)
1158         return WINED3D_TEXF_LINEAR;
1159     return WINED3D_TEXF_POINT;
1160 }
1161
1162 static BOOL wined3d_texture_compare_from_d3d11(enum D3D11_FILTER f)
1163 {
1164     return D3D11_DECODE_IS_COMPARISON_FILTER(f);
1165 }
1166
1167 static enum wined3d_cmp_func wined3d_cmp_func_from_d3d11(D3D11_COMPARISON_FUNC f)
1168 {
1169     return (enum wined3d_cmp_func)f;
1170 }
1171
1172 HRESULT d3d_sampler_state_init(struct d3d_sampler_state *state, struct d3d_device *device,
1173         const D3D11_SAMPLER_DESC *desc)
1174 {
1175     struct wined3d_sampler_desc wined3d_desc;
1176     HRESULT hr;
1177
1178     state->ID3D11SamplerState_iface.lpVtbl = &d3d11_sampler_state_vtbl;
1179     state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
1180     state->refcount = 1;
1181     wined3d_mutex_lock();
1182     wined3d_private_store_init(&state->private_store);
1183     state->desc = *desc;
1184
1185     wined3d_desc.address_u = wined3d_texture_address_from_d3d11(desc->AddressU);
1186     wined3d_desc.address_v = wined3d_texture_address_from_d3d11(desc->AddressV);
1187     wined3d_desc.address_w = wined3d_texture_address_from_d3d11(desc->AddressW);
1188     memcpy(wined3d_desc.border_color, desc->BorderColor, sizeof(wined3d_desc.border_color));
1189     wined3d_desc.mag_filter = wined3d_texture_filter_mag_from_d3d11(desc->Filter);
1190     wined3d_desc.min_filter = wined3d_texture_filter_min_from_d3d11(desc->Filter);
1191     wined3d_desc.mip_filter = wined3d_texture_filter_mip_from_d3d11(desc->Filter);
1192     wined3d_desc.lod_bias = desc->MipLODBias;
1193     wined3d_desc.min_lod = desc->MinLOD;
1194     wined3d_desc.max_lod = desc->MaxLOD;
1195     wined3d_desc.max_anisotropy = D3D11_DECODE_IS_ANISOTROPIC_FILTER(desc->Filter) ? desc->MaxAnisotropy : 1;
1196     wined3d_desc.compare = wined3d_texture_compare_from_d3d11(desc->Filter);
1197     wined3d_desc.comparison_func = wined3d_cmp_func_from_d3d11(desc->ComparisonFunc);
1198     wined3d_desc.srgb_decode = FALSE;
1199
1200     if (FAILED(hr = wined3d_sampler_create(device->wined3d_device, &wined3d_desc, state, &state->wined3d_sampler)))
1201     {
1202         WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
1203         wined3d_private_store_cleanup(&state->private_store);
1204         wined3d_mutex_unlock();
1205         return hr;
1206     }
1207
1208     if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
1209     {
1210         ERR("Failed to insert sampler state entry.\n");
1211         wined3d_sampler_decref(state->wined3d_sampler);
1212         wined3d_private_store_cleanup(&state->private_store);
1213         wined3d_mutex_unlock();
1214         return E_FAIL;
1215     }
1216     wined3d_mutex_unlock();
1217
1218     state->device = &device->ID3D11Device_iface;
1219     ID3D11Device_AddRef(state->device);
1220
1221     return S_OK;
1222 }
1223
1224 struct d3d_sampler_state *unsafe_impl_from_ID3D11SamplerState(ID3D11SamplerState *iface)
1225 {
1226     if (!iface)
1227         return NULL;
1228     assert(iface->lpVtbl == &d3d11_sampler_state_vtbl);
1229
1230     return impl_from_ID3D11SamplerState(iface);
1231 }
1232
1233 struct d3d_sampler_state *unsafe_impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
1234 {
1235     if (!iface)
1236         return NULL;
1237     assert(iface->lpVtbl == &d3d10_sampler_state_vtbl);
1238
1239     return impl_from_ID3D10SamplerState(iface);
1240 }