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