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