dlls/d3d11/state.c

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