dlls/d3d10core/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 "d3d10core_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d10core);
  26
  27 static inline struct d3d10_blend_state *impl_from_ID3D10BlendState(ID3D10BlendState *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct d3d10_blend_state, ID3D10BlendState_iface);
  30 }
  31
  32 /* IUnknown methods */
  33
  34 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_QueryInterface(ID3D10BlendState *iface,
  35         REFIID riid, void **object)
  36 {
  37     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
  38
  39     if (IsEqualGUID(riid, &IID_ID3D10BlendState)
  40             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
  41             || IsEqualGUID(riid, &IID_IUnknown))
  42     {
  43         IUnknown_AddRef(iface);
  44         *object = iface;
  45         return S_OK;
  46     }
  47
  48     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
  49
  50     *object = NULL;
  51     return E_NOINTERFACE;
  52 }
  53
  54 static ULONG STDMETHODCALLTYPE d3d10_blend_state_AddRef(ID3D10BlendState *iface)
  55 {
  56     struct d3d10_blend_state *This = impl_from_ID3D10BlendState(iface);
  57     ULONG refcount = InterlockedIncrement(&This->refcount);
  58
  59     TRACE("%p increasing refcount to %u.\n", This, refcount);
  60
  61     return refcount;
  62 }
  63
  64 static ULONG STDMETHODCALLTYPE d3d10_blend_state_Release(ID3D10BlendState *iface)
  65 {
  66     struct d3d10_blend_state *state = impl_from_ID3D10BlendState(iface);
  67     ULONG refcount = InterlockedDecrement(&state->refcount);
  68
  69     TRACE("%p decreasing refcount to %u.\n", state, refcount);
  70
  71     if (!refcount)
  72     {
  73         struct d3d10_device *device = impl_from_ID3D10Device(state->device);
  74         wine_rb_remove(&device->blend_states, &state->desc);
  75         ID3D10Device1_Release(state->device);
  76         HeapFree(GetProcessHeap(), 0, state);
  77     }
  78
  79     return refcount;
  80 }
  81
  82 /* ID3D10DeviceChild methods */
  83
  84 static void STDMETHODCALLTYPE d3d10_blend_state_GetDevice(ID3D10BlendState *iface, ID3D10Device **device)
  85 {
  86     struct d3d10_blend_state *state = impl_from_ID3D10BlendState(iface);
  87
  88     TRACE("iface %p, device %p.\n", iface, device);
  89
  90     *device = (ID3D10Device *)state->device;
  91     ID3D10Device_AddRef(*device);
  92 }
  93
  94 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_GetPrivateData(ID3D10BlendState *iface,
  95         REFGUID guid, UINT *data_size, void *data)
  96 {
  97     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
  98             iface, debugstr_guid(guid), data_size, data);
  99
 100     return E_NOTIMPL;
 101 }
 102
 103 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateData(ID3D10BlendState *iface,
 104         REFGUID guid, UINT data_size, const void *data)
 105 {
 106     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 107             iface, debugstr_guid(guid), data_size, data);
 108
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT STDMETHODCALLTYPE d3d10_blend_state_SetPrivateDataInterface(ID3D10BlendState *iface,
 113         REFGUID guid, const IUnknown *data)
 114 {
 115     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 116
 117     return E_NOTIMPL;
 118 }
 119
 120 /* ID3D10BlendState methods */
 121
 122 static void STDMETHODCALLTYPE d3d10_blend_state_GetDesc(ID3D10BlendState *iface,
 123         D3D10_BLEND_DESC *desc)
 124 {
 125     struct d3d10_blend_state *state = impl_from_ID3D10BlendState(iface);
 126
 127     TRACE("iface %p, desc %p.\n", iface, desc);
 128
 129     *desc = state->desc;
 130 }
 131
 132 static const struct ID3D10BlendStateVtbl d3d10_blend_state_vtbl =
 133 {
 134     /* IUnknown methods */
 135     d3d10_blend_state_QueryInterface,
 136     d3d10_blend_state_AddRef,
 137     d3d10_blend_state_Release,
 138     /* ID3D10DeviceChild methods */
 139     d3d10_blend_state_GetDevice,
 140     d3d10_blend_state_GetPrivateData,
 141     d3d10_blend_state_SetPrivateData,
 142     d3d10_blend_state_SetPrivateDataInterface,
 143     /* ID3D10BlendState methods */
 144     d3d10_blend_state_GetDesc,
 145 };
 146
 147 HRESULT d3d10_blend_state_init(struct d3d10_blend_state *state, struct d3d10_device *device,
 148         const D3D10_BLEND_DESC *desc)
 149 {
 150     state->ID3D10BlendState_iface.lpVtbl = &d3d10_blend_state_vtbl;
 151     state->refcount = 1;
 152     state->desc = *desc;
 153
 154     if (wine_rb_put(&device->blend_states, desc, &state->entry) == -1)
 155     {
 156         ERR("Failed to insert blend state entry.\n");
 157         return E_FAIL;
 158     }
 159
 160     state->device = &device->ID3D10Device1_iface;
 161     ID3D10Device1_AddRef(state->device);
 162
 163     return S_OK;
 164 }
 165
 166 struct d3d10_blend_state *unsafe_impl_from_ID3D10BlendState(ID3D10BlendState *iface)
 167 {
 168     if (!iface)
 169         return NULL;
 170     assert(iface->lpVtbl == &d3d10_blend_state_vtbl);
 171
 172     return impl_from_ID3D10BlendState(iface);
 173 }
 174
 175 static inline struct d3d10_depthstencil_state *impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 176 {
 177     return CONTAINING_RECORD(iface, struct d3d10_depthstencil_state, ID3D10DepthStencilState_iface);
 178 }
 179
 180 /* IUnknown methods */
 181
 182 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_QueryInterface(ID3D10DepthStencilState *iface,
 183         REFIID riid, void **object)
 184 {
 185     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 186
 187     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilState)
 188             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 189             || IsEqualGUID(riid, &IID_IUnknown))
 190     {
 191         IUnknown_AddRef(iface);
 192         *object = iface;
 193         return S_OK;
 194     }
 195
 196     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 197
 198     *object = NULL;
 199     return E_NOINTERFACE;
 200 }
 201
 202 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_AddRef(ID3D10DepthStencilState *iface)
 203 {
 204     struct d3d10_depthstencil_state *This = impl_from_ID3D10DepthStencilState(iface);
 205     ULONG refcount = InterlockedIncrement(&This->refcount);
 206
 207     TRACE("%p increasing refcount to %u.\n", This, refcount);
 208
 209     return refcount;
 210 }
 211
 212 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_state_Release(ID3D10DepthStencilState *iface)
 213 {
 214     struct d3d10_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 215     ULONG refcount = InterlockedDecrement(&state->refcount);
 216
 217     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 218
 219     if (!refcount)
 220     {
 221         struct d3d10_device *device = impl_from_ID3D10Device(state->device);
 222         wine_rb_remove(&device->depthstencil_states, &state->desc);
 223         ID3D10Device1_Release(state->device);
 224         HeapFree(GetProcessHeap(), 0, state);
 225     }
 226
 227     return refcount;
 228 }
 229
 230 /* ID3D10DeviceChild methods */
 231
 232 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDevice(ID3D10DepthStencilState *iface, ID3D10Device **device)
 233 {
 234     struct d3d10_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 235
 236     TRACE("iface %p, device %p.\n", iface, device);
 237
 238     *device = (ID3D10Device *)state->device;
 239     ID3D10Device_AddRef(*device);
 240 }
 241
 242 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_GetPrivateData(ID3D10DepthStencilState *iface,
 243         REFGUID guid, UINT *data_size, void *data)
 244 {
 245     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 246             iface, debugstr_guid(guid), data_size, data);
 247
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateData(ID3D10DepthStencilState *iface,
 252         REFGUID guid, UINT data_size, const void *data)
 253 {
 254     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 255             iface, debugstr_guid(guid), data_size, data);
 256
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_state_SetPrivateDataInterface(ID3D10DepthStencilState *iface,
 261         REFGUID guid, const IUnknown *data)
 262 {
 263     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 264
 265     return E_NOTIMPL;
 266 }
 267
 268 /* ID3D10DepthStencilState methods */
 269
 270 static void STDMETHODCALLTYPE d3d10_depthstencil_state_GetDesc(ID3D10DepthStencilState *iface,
 271         D3D10_DEPTH_STENCIL_DESC *desc)
 272 {
 273     struct d3d10_depthstencil_state *state = impl_from_ID3D10DepthStencilState(iface);
 274
 275     TRACE("iface %p, desc %p.\n", iface, desc);
 276
 277     *desc = state->desc;
 278 }
 279
 280 static const struct ID3D10DepthStencilStateVtbl d3d10_depthstencil_state_vtbl =
 281 {
 282     /* IUnknown methods */
 283     d3d10_depthstencil_state_QueryInterface,
 284     d3d10_depthstencil_state_AddRef,
 285     d3d10_depthstencil_state_Release,
 286     /* ID3D10DeviceChild methods */
 287     d3d10_depthstencil_state_GetDevice,
 288     d3d10_depthstencil_state_GetPrivateData,
 289     d3d10_depthstencil_state_SetPrivateData,
 290     d3d10_depthstencil_state_SetPrivateDataInterface,
 291     /* ID3D10DepthStencilState methods */
 292     d3d10_depthstencil_state_GetDesc,
 293 };
 294
 295 HRESULT d3d10_depthstencil_state_init(struct d3d10_depthstencil_state *state, struct d3d10_device *device,
 296         const D3D10_DEPTH_STENCIL_DESC *desc)
 297 {
 298     state->ID3D10DepthStencilState_iface.lpVtbl = &d3d10_depthstencil_state_vtbl;
 299     state->refcount = 1;
 300     state->desc = *desc;
 301
 302     if (wine_rb_put(&device->depthstencil_states, desc, &state->entry) == -1)
 303     {
 304         ERR("Failed to insert depthstencil state entry.\n");
 305         return E_FAIL;
 306     }
 307
 308     state->device = &device->ID3D10Device1_iface;
 309     ID3D10Device1_AddRef(state->device);
 310
 311     return S_OK;
 312 }
 313
 314 struct d3d10_depthstencil_state *unsafe_impl_from_ID3D10DepthStencilState(ID3D10DepthStencilState *iface)
 315 {
 316     if (!iface)
 317         return NULL;
 318     assert(iface->lpVtbl == &d3d10_depthstencil_state_vtbl);
 319
 320     return impl_from_ID3D10DepthStencilState(iface);
 321 }
 322
 323 static inline struct d3d10_rasterizer_state *impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 324 {
 325     return CONTAINING_RECORD(iface, struct d3d10_rasterizer_state, ID3D10RasterizerState_iface);
 326 }
 327
 328 /* IUnknown methods */
 329
 330 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_QueryInterface(ID3D10RasterizerState *iface,
 331         REFIID riid, void **object)
 332 {
 333     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 334
 335     if (IsEqualGUID(riid, &IID_ID3D10RasterizerState)
 336             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 337             || IsEqualGUID(riid, &IID_IUnknown))
 338     {
 339         IUnknown_AddRef(iface);
 340         *object = iface;
 341         return S_OK;
 342     }
 343
 344     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 345
 346     *object = NULL;
 347     return E_NOINTERFACE;
 348 }
 349
 350 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_AddRef(ID3D10RasterizerState *iface)
 351 {
 352     struct d3d10_rasterizer_state *This = impl_from_ID3D10RasterizerState(iface);
 353     ULONG refcount = InterlockedIncrement(&This->refcount);
 354
 355     TRACE("%p increasing refcount to %u.\n", This, refcount);
 356
 357     return refcount;
 358 }
 359
 360 static ULONG STDMETHODCALLTYPE d3d10_rasterizer_state_Release(ID3D10RasterizerState *iface)
 361 {
 362     struct d3d10_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 363     ULONG refcount = InterlockedDecrement(&state->refcount);
 364
 365     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 366
 367     if (!refcount)
 368     {
 369         struct d3d10_device *device = impl_from_ID3D10Device(state->device);
 370         wine_rb_remove(&device->rasterizer_states, &state->desc);
 371         ID3D10Device1_Release(state->device);
 372         HeapFree(GetProcessHeap(), 0, state);
 373     }
 374
 375     return refcount;
 376 }
 377
 378 /* ID3D10DeviceChild methods */
 379
 380 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDevice(ID3D10RasterizerState *iface, ID3D10Device **device)
 381 {
 382     struct d3d10_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 383
 384     TRACE("iface %p, device %p.\n", iface, device);
 385
 386     *device = (ID3D10Device *)state->device;
 387     ID3D10Device_AddRef(*device);
 388 }
 389
 390 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_GetPrivateData(ID3D10RasterizerState *iface,
 391         REFGUID guid, UINT *data_size, void *data)
 392 {
 393     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 394             iface, debugstr_guid(guid), data_size, data);
 395
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateData(ID3D10RasterizerState *iface,
 400         REFGUID guid, UINT data_size, const void *data)
 401 {
 402     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 403             iface, debugstr_guid(guid), data_size, data);
 404
 405     return E_NOTIMPL;
 406 }
 407
 408 static HRESULT STDMETHODCALLTYPE d3d10_rasterizer_state_SetPrivateDataInterface(ID3D10RasterizerState *iface,
 409         REFGUID guid, const IUnknown *data)
 410 {
 411     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 412
 413     return E_NOTIMPL;
 414 }
 415
 416 /* ID3D10RasterizerState methods */
 417
 418 static void STDMETHODCALLTYPE d3d10_rasterizer_state_GetDesc(ID3D10RasterizerState *iface,
 419         D3D10_RASTERIZER_DESC *desc)
 420 {
 421     struct d3d10_rasterizer_state *state = impl_from_ID3D10RasterizerState(iface);
 422
 423     TRACE("iface %p, desc %p.\n", iface, desc);
 424
 425     *desc = state->desc;
 426 }
 427
 428 static const struct ID3D10RasterizerStateVtbl d3d10_rasterizer_state_vtbl =
 429 {
 430     /* IUnknown methods */
 431     d3d10_rasterizer_state_QueryInterface,
 432     d3d10_rasterizer_state_AddRef,
 433     d3d10_rasterizer_state_Release,
 434     /* ID3D10DeviceChild methods */
 435     d3d10_rasterizer_state_GetDevice,
 436     d3d10_rasterizer_state_GetPrivateData,
 437     d3d10_rasterizer_state_SetPrivateData,
 438     d3d10_rasterizer_state_SetPrivateDataInterface,
 439     /* ID3D10RasterizerState methods */
 440     d3d10_rasterizer_state_GetDesc,
 441 };
 442
 443 HRESULT d3d10_rasterizer_state_init(struct d3d10_rasterizer_state *state, struct d3d10_device *device,
 444         const D3D10_RASTERIZER_DESC *desc)
 445 {
 446     state->ID3D10RasterizerState_iface.lpVtbl = &d3d10_rasterizer_state_vtbl;
 447     state->refcount = 1;
 448     state->desc = *desc;
 449
 450     if (wine_rb_put(&device->rasterizer_states, desc, &state->entry) == -1)
 451     {
 452         ERR("Failed to insert rasterizer state entry.\n");
 453         return E_FAIL;
 454     }
 455
 456     state->device = &device->ID3D10Device1_iface;
 457     ID3D10Device1_AddRef(state->device);
 458
 459     return S_OK;
 460 }
 461
 462 struct d3d10_rasterizer_state *unsafe_impl_from_ID3D10RasterizerState(ID3D10RasterizerState *iface)
 463 {
 464     if (!iface)
 465         return NULL;
 466     assert(iface->lpVtbl == &d3d10_rasterizer_state_vtbl);
 467
 468     return impl_from_ID3D10RasterizerState(iface);
 469 }
 470
 471 static inline struct d3d10_sampler_state *impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
 472 {
 473     return CONTAINING_RECORD(iface, struct d3d10_sampler_state, ID3D10SamplerState_iface);
 474 }
 475
 476 /* IUnknown methods */
 477
 478 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_QueryInterface(ID3D10SamplerState *iface,
 479         REFIID riid, void **object)
 480 {
 481     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 482
 483     if (IsEqualGUID(riid, &IID_ID3D10SamplerState)
 484             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 485             || IsEqualGUID(riid, &IID_IUnknown))
 486     {
 487         IUnknown_AddRef(iface);
 488         *object = iface;
 489         return S_OK;
 490     }
 491
 492     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 493
 494     *object = NULL;
 495     return E_NOINTERFACE;
 496 }
 497
 498 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_AddRef(ID3D10SamplerState *iface)
 499 {
 500     struct d3d10_sampler_state *This = impl_from_ID3D10SamplerState(iface);
 501     ULONG refcount = InterlockedIncrement(&This->refcount);
 502
 503     TRACE("%p increasing refcount to %u.\n", This, refcount);
 504
 505     return refcount;
 506 }
 507
 508 static ULONG STDMETHODCALLTYPE d3d10_sampler_state_Release(ID3D10SamplerState *iface)
 509 {
 510     struct d3d10_sampler_state *state = impl_from_ID3D10SamplerState(iface);
 511     ULONG refcount = InterlockedDecrement(&state->refcount);
 512
 513     TRACE("%p decreasing refcount to %u.\n", state, refcount);
 514
 515     if (!refcount)
 516     {
 517         struct d3d10_device *device = impl_from_ID3D10Device(state->device);
 518
 519         wined3d_sampler_decref(state->wined3d_sampler);
 520         wine_rb_remove(&device->sampler_states, &state->desc);
 521         ID3D10Device1_Release(state->device);
 522         HeapFree(GetProcessHeap(), 0, state);
 523     }
 524
 525     return refcount;
 526 }
 527
 528 /* ID3D10DeviceChild methods */
 529
 530 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDevice(ID3D10SamplerState *iface, ID3D10Device **device)
 531 {
 532     struct d3d10_sampler_state *state = impl_from_ID3D10SamplerState(iface);
 533
 534     TRACE("iface %p, device %p.\n", iface, device);
 535
 536     *device = (ID3D10Device *)state->device;
 537     ID3D10Device_AddRef(*device);
 538 }
 539
 540 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_GetPrivateData(ID3D10SamplerState *iface,
 541         REFGUID guid, UINT *data_size, void *data)
 542 {
 543     FIXME("iface %p, guid %s, data_size %p, data %p stub!\n",
 544             iface, debugstr_guid(guid), data_size, data);
 545
 546     return E_NOTIMPL;
 547 }
 548
 549 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateData(ID3D10SamplerState *iface,
 550         REFGUID guid, UINT data_size, const void *data)
 551 {
 552     FIXME("iface %p, guid %s, data_size %u, data %p stub!\n",
 553             iface, debugstr_guid(guid), data_size, data);
 554
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT STDMETHODCALLTYPE d3d10_sampler_state_SetPrivateDataInterface(ID3D10SamplerState *iface,
 559         REFGUID guid, const IUnknown *data)
 560 {
 561     FIXME("iface %p, guid %s, data %p stub!\n", iface, debugstr_guid(guid), data);
 562
 563     return E_NOTIMPL;
 564 }
 565
 566 /* ID3D10SamplerState methods */
 567
 568 static void STDMETHODCALLTYPE d3d10_sampler_state_GetDesc(ID3D10SamplerState *iface,
 569         D3D10_SAMPLER_DESC *desc)
 570 {
 571     struct d3d10_sampler_state *state = impl_from_ID3D10SamplerState(iface);
 572
 573     TRACE("iface %p, desc %p.\n", iface, desc);
 574
 575     *desc = state->desc;
 576 }
 577
 578 static const struct ID3D10SamplerStateVtbl d3d10_sampler_state_vtbl =
 579 {
 580     /* IUnknown methods */
 581     d3d10_sampler_state_QueryInterface,
 582     d3d10_sampler_state_AddRef,
 583     d3d10_sampler_state_Release,
 584     /* ID3D10DeviceChild methods */
 585     d3d10_sampler_state_GetDevice,
 586     d3d10_sampler_state_GetPrivateData,
 587     d3d10_sampler_state_SetPrivateData,
 588     d3d10_sampler_state_SetPrivateDataInterface,
 589     /* ID3D10SamplerState methods */
 590     d3d10_sampler_state_GetDesc,
 591 };
 592
 593 HRESULT d3d10_sampler_state_init(struct d3d10_sampler_state *state, struct d3d10_device *device,
 594         const D3D10_SAMPLER_DESC *desc)
 595 {
 596     HRESULT hr;
 597
 598     state->ID3D10SamplerState_iface.lpVtbl = &d3d10_sampler_state_vtbl;
 599     state->refcount = 1;
 600     state->desc = *desc;
 601
 602     if (FAILED(hr = wined3d_sampler_create(state, &state->wined3d_sampler)))
 603     {
 604         WARN("Failed to create wined3d sampler, hr %#x.\n", hr);
 605         return hr;
 606     }
 607
 608     if (wine_rb_put(&device->sampler_states, desc, &state->entry) == -1)
 609     {
 610         ERR("Failed to insert sampler state entry.\n");
 611         wined3d_sampler_decref(state->wined3d_sampler);
 612         return E_FAIL;
 613     }
 614
 615     state->device = &device->ID3D10Device1_iface;
 616     ID3D10Device1_AddRef(state->device);
 617
 618     return S_OK;
 619 }
 620
 621 struct d3d10_sampler_state *unsafe_impl_from_ID3D10SamplerState(ID3D10SamplerState *iface)
 622 {
 623     if (!iface)
 624         return NULL;
 625     assert(iface->lpVtbl == &d3d10_sampler_state_vtbl);
 626
 627     return impl_from_ID3D10SamplerState(iface);
 628 }