dlls/d2d1/brush.c

   1 /*
   2  * Copyright 2014 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 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include "d2d1_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  25
  26 static inline struct d2d_gradient *impl_from_ID2D1GradientStopCollection(ID2D1GradientStopCollection *iface)
  27 {
  28     return CONTAINING_RECORD(iface, struct d2d_gradient, ID2D1GradientStopCollection_iface);
  29 }
  30
  31 static HRESULT STDMETHODCALLTYPE d2d_gradient_QueryInterface(ID2D1GradientStopCollection *iface,
  32         REFIID iid, void **out)
  33 {
  34     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  35
  36     if (IsEqualGUID(iid, &IID_ID2D1GradientStopCollection)
  37             || IsEqualGUID(iid, &IID_ID2D1Resource)
  38             || IsEqualGUID(iid, &IID_IUnknown))
  39     {
  40         ID2D1GradientStopCollection_AddRef(iface);
  41         *out = iface;
  42         return S_OK;
  43     }
  44
  45     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  46
  47     *out = NULL;
  48     return E_NOINTERFACE;
  49 }
  50
  51 static ULONG STDMETHODCALLTYPE d2d_gradient_AddRef(ID2D1GradientStopCollection *iface)
  52 {
  53     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  54     ULONG refcount = InterlockedIncrement(&gradient->refcount);
  55
  56     TRACE("%p increasing refcount to %u.\n", iface, refcount);
  57
  58     return refcount;
  59 }
  60
  61 static ULONG STDMETHODCALLTYPE d2d_gradient_Release(ID2D1GradientStopCollection *iface)
  62 {
  63     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  64     ULONG refcount = InterlockedDecrement(&gradient->refcount);
  65
  66     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
  67
  68     if (!refcount)
  69     {
  70         HeapFree(GetProcessHeap(), 0, gradient->stops);
  71         HeapFree(GetProcessHeap(), 0, gradient);
  72     }
  73
  74     return refcount;
  75 }
  76
  77 static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory)
  78 {
  79     FIXME("iface %p, factory %p stub!\n", iface, factory);
  80
  81     *factory = NULL;
  82 }
  83
  84 static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface)
  85 {
  86     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  87
  88     TRACE("iface %p.\n", iface);
  89
  90     return gradient->stop_count;
  91 }
  92
  93 static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface,
  94         D2D1_GRADIENT_STOP *stops, UINT32 stop_count)
  95 {
  96     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  97
  98     TRACE("iface %p, stops %p, stop_count %u.\n", iface, stops, stop_count);
  99
 100     memcpy(stops, gradient->stops, min(gradient->stop_count, stop_count) * sizeof(*stops));
 101     if (stop_count > gradient->stop_count)
 102         memset(stops, 0, (stop_count - gradient->stop_count) * sizeof(*stops));
 103 }
 104
 105 static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface)
 106 {
 107     FIXME("iface %p stub!\n", iface);
 108
 109     return D2D1_GAMMA_1_0;
 110 }
 111
 112 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface)
 113 {
 114     FIXME("iface %p stub!\n", iface);
 115
 116     return D2D1_EXTEND_MODE_CLAMP;
 117 }
 118
 119 static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl =
 120 {
 121     d2d_gradient_QueryInterface,
 122     d2d_gradient_AddRef,
 123     d2d_gradient_Release,
 124     d2d_gradient_GetFactory,
 125     d2d_gradient_GetGradientStopCount,
 126     d2d_gradient_GetGradientStops,
 127     d2d_gradient_GetColorInterpolationGamma,
 128     d2d_gradient_GetExtendMode,
 129 };
 130
 131 HRESULT d2d_gradient_init(struct d2d_gradient *gradient, ID2D1RenderTarget *render_target,
 132         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode)
 133 {
 134     FIXME("Ignoring gradient properties.\n");
 135
 136     gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
 137     gradient->refcount = 1;
 138
 139     gradient->stop_count = stop_count;
 140     if (!(gradient->stops = HeapAlloc(GetProcessHeap(), 0, stop_count * sizeof(*stops))))
 141         return E_OUTOFMEMORY;
 142     memcpy(gradient->stops, stops, stop_count * sizeof(*stops));
 143
 144     return S_OK;
 145 }
 146
 147 static void d2d_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 148         enum d2d_brush_type type, const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl)
 149 {
 150     static const D2D1_MATRIX_3X2_F identity =
 151     {
 152         1.0f, 0.0f,
 153         0.0f, 1.0f,
 154         0.0f, 0.0f,
 155     };
 156
 157     brush->ID2D1Brush_iface.lpVtbl = vtbl;
 158     brush->refcount = 1;
 159     brush->opacity = desc ? desc->opacity : 1.0f;
 160     brush->transform = desc ? desc->transform : identity;
 161     brush->type = type;
 162 }
 163
 164 static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface)
 165 {
 166     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 167 }
 168
 169 static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface,
 170         REFIID iid, void **out)
 171 {
 172     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 173
 174     if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush)
 175             || IsEqualGUID(iid, &IID_ID2D1Brush)
 176             || IsEqualGUID(iid, &IID_ID2D1Resource)
 177             || IsEqualGUID(iid, &IID_IUnknown))
 178     {
 179         ID2D1SolidColorBrush_AddRef(iface);
 180         *out = iface;
 181         return S_OK;
 182     }
 183
 184     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 185
 186     *out = NULL;
 187     return E_NOINTERFACE;
 188 }
 189
 190 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface)
 191 {
 192     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 193     ULONG refcount = InterlockedIncrement(&brush->refcount);
 194
 195     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 196
 197     return refcount;
 198 }
 199
 200 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface)
 201 {
 202     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 203     ULONG refcount = InterlockedDecrement(&brush->refcount);
 204
 205     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 206
 207     if (!refcount)
 208         HeapFree(GetProcessHeap(), 0, brush);
 209
 210     return refcount;
 211 }
 212
 213 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory)
 214 {
 215     FIXME("iface %p, factory %p stub!\n", iface, factory);
 216
 217     *factory = NULL;
 218 }
 219
 220 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity)
 221 {
 222     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 223
 224     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 225
 226     brush->opacity = opacity;
 227 }
 228
 229 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface,
 230         const D2D1_MATRIX_3X2_F *transform)
 231 {
 232     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 233
 234     TRACE("iface %p, transform %p.\n", iface, transform);
 235
 236     brush->transform = *transform;
 237 }
 238
 239 static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface)
 240 {
 241     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 242
 243     TRACE("iface %p.\n", iface);
 244
 245     return brush->opacity;
 246 }
 247
 248 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface,
 249         D2D1_MATRIX_3X2_F *transform)
 250 {
 251     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 252
 253     TRACE("iface %p, transform %p.\n", iface, transform);
 254
 255     *transform = brush->transform;
 256 }
 257
 258 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color)
 259 {
 260     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 261
 262     TRACE("iface %p, color %p.\n", iface, color);
 263
 264     brush->u.solid.color = *color;
 265 }
 266
 267 static D2D1_COLOR_F * STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface, D2D1_COLOR_F *color)
 268 {
 269     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 270
 271     TRACE("iface %p, color %p.\n", iface, color);
 272
 273     *color = brush->u.solid.color;
 274     return color;
 275 }
 276
 277 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 278 {
 279     d2d_solid_color_brush_QueryInterface,
 280     d2d_solid_color_brush_AddRef,
 281     d2d_solid_color_brush_Release,
 282     d2d_solid_color_brush_GetFactory,
 283     d2d_solid_color_brush_SetOpacity,
 284     d2d_solid_color_brush_SetTransform,
 285     d2d_solid_color_brush_GetOpacity,
 286     d2d_solid_color_brush_GetTransform,
 287     d2d_solid_color_brush_SetColor,
 288     d2d_solid_color_brush_GetColor,
 289 };
 290
 291 void d2d_solid_color_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 292         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc)
 293 {
 294     FIXME("Ignoring brush properties.\n");
 295
 296     d2d_brush_init(brush, render_target, D2D_BRUSH_TYPE_SOLID, desc,
 297             (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 298     brush->u.solid.color = *color;
 299 }
 300
 301 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 302 {
 303     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 304 }
 305
 306 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 307         REFIID iid, void **out)
 308 {
 309     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 310
 311     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 312             || IsEqualGUID(iid, &IID_ID2D1Brush)
 313             || IsEqualGUID(iid, &IID_ID2D1Resource)
 314             || IsEqualGUID(iid, &IID_IUnknown))
 315     {
 316         ID2D1LinearGradientBrush_AddRef(iface);
 317         *out = iface;
 318         return S_OK;
 319     }
 320
 321     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 322
 323     *out = NULL;
 324     return E_NOINTERFACE;
 325 }
 326
 327 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 328 {
 329     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 330     ULONG refcount = InterlockedIncrement(&brush->refcount);
 331
 332     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 333
 334     return refcount;
 335 }
 336
 337 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 338 {
 339     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 340     ULONG refcount = InterlockedDecrement(&brush->refcount);
 341
 342     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 343
 344     if (!refcount)
 345         HeapFree(GetProcessHeap(), 0, brush);
 346
 347     return refcount;
 348 }
 349
 350 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 351         ID2D1Factory **factory)
 352 {
 353     FIXME("iface %p, factory %p stub!\n", iface, factory);
 354
 355     *factory = NULL;
 356 }
 357
 358 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 359 {
 360     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 361 }
 362
 363 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 364         const D2D1_MATRIX_3X2_F *transform)
 365 {
 366     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 367
 368     TRACE("iface %p, transform %p.\n", iface, transform);
 369
 370     brush->transform = *transform;
 371 }
 372
 373 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 374 {
 375     FIXME("iface %p stub!\n", iface);
 376
 377     return 0.0f;
 378 }
 379
 380 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 381         D2D1_MATRIX_3X2_F *transform)
 382 {
 383     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 384
 385     TRACE("iface %p, transform %p.\n", iface, transform);
 386
 387     *transform = brush->transform;
 388 }
 389
 390 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 391         D2D1_POINT_2F start_point)
 392 {
 393     FIXME("iface %p, start_point {%.8e, %.8e} stub!\n", iface, start_point.x, start_point.y);
 394 }
 395
 396 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 397         D2D1_POINT_2F end_point)
 398 {
 399     FIXME("iface %p, end_point {%.8e, %.8e} stub!\n", iface, end_point.x, end_point.y);
 400 }
 401
 402 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface,
 403         D2D1_POINT_2F *point)
 404 {
 405     FIXME("iface %p, point %p stub!\n", iface, point);
 406
 407     point->x = 0.0f;
 408     point->y = 0.0f;
 409     return point;
 410 }
 411
 412 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface,
 413         D2D1_POINT_2F *point)
 414 {
 415     FIXME("iface %p, point %p stub!\n", iface, point);
 416
 417     point->x = 0.0f;
 418     point->y = 0.0f;
 419     return point;
 420 }
 421
 422 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 423         ID2D1GradientStopCollection **gradient)
 424 {
 425     FIXME("iface %p, gradient %p stub!\n", iface, gradient);
 426
 427     *gradient = NULL;
 428 }
 429
 430 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 431 {
 432     d2d_linear_gradient_brush_QueryInterface,
 433     d2d_linear_gradient_brush_AddRef,
 434     d2d_linear_gradient_brush_Release,
 435     d2d_linear_gradient_brush_GetFactory,
 436     d2d_linear_gradient_brush_SetOpacity,
 437     d2d_linear_gradient_brush_SetTransform,
 438     d2d_linear_gradient_brush_GetOpacity,
 439     d2d_linear_gradient_brush_GetTransform,
 440     d2d_linear_gradient_brush_SetStartPoint,
 441     d2d_linear_gradient_brush_SetEndPoint,
 442     d2d_linear_gradient_brush_GetStartPoint,
 443     d2d_linear_gradient_brush_GetEndPoint,
 444     d2d_linear_gradient_brush_GetGradientStopCollection,
 445 };
 446
 447 void d2d_linear_gradient_brush_init(struct d2d_brush *brush, ID2D1RenderTarget *render_target,
 448         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 449         ID2D1GradientStopCollection *gradient)
 450 {
 451     FIXME("Ignoring brush properties.\n");
 452
 453     d2d_brush_init(brush, render_target, D2D_BRUSH_TYPE_LINEAR, brush_desc,
 454             (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl);
 455 }
 456
 457 static inline struct d2d_brush *impl_from_ID2D1BitmapBrush(ID2D1BitmapBrush *iface)
 458 {
 459     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 460 }
 461
 462 static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush *iface,
 463         REFIID iid, void **out)
 464 {
 465     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 466
 467     if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush)
 468             || IsEqualGUID(iid, &IID_ID2D1Brush)
 469             || IsEqualGUID(iid, &IID_ID2D1Resource)
 470             || IsEqualGUID(iid, &IID_IUnknown))
 471     {
 472         ID2D1BitmapBrush_AddRef(iface);
 473         *out = iface;
 474         return S_OK;
 475     }
 476
 477     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 478
 479     *out = NULL;
 480     return E_NOINTERFACE;
 481 }
 482
 483 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface)
 484 {
 485     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 486     ULONG refcount = InterlockedIncrement(&brush->refcount);
 487
 488     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 489
 490     return refcount;
 491 }
 492
 493 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface)
 494 {
 495     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 496     ULONG refcount = InterlockedDecrement(&brush->refcount);
 497
 498     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 499
 500     if (!refcount)
 501     {
 502         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 503         HeapFree(GetProcessHeap(), 0, brush);
 504     }
 505
 506     return refcount;
 507 }
 508
 509 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush *iface,
 510         ID2D1Factory **factory)
 511 {
 512     FIXME("iface %p, factory %p stub!\n", iface, factory);
 513
 514     *factory = NULL;
 515 }
 516
 517 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush *iface, float opacity)
 518 {
 519     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 520
 521     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 522
 523     brush->opacity = opacity;
 524 }
 525
 526 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush *iface,
 527         const D2D1_MATRIX_3X2_F *transform)
 528 {
 529     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 530
 531     TRACE("iface %p, transform %p.\n", iface, transform);
 532
 533     brush->transform = *transform;
 534 }
 535
 536 static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush *iface)
 537 {
 538     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 539
 540     TRACE("iface %p.\n", iface);
 541
 542     return brush->opacity;
 543 }
 544
 545 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush *iface,
 546         D2D1_MATRIX_3X2_F *transform)
 547 {
 548     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 549
 550     TRACE("iface %p, transform %p.\n", iface, transform);
 551
 552     *transform = brush->transform;
 553 }
 554
 555 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 556 {
 557     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 558 }
 559
 560 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 561 {
 562     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 563 }
 564
 565 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush *iface,
 566         D2D1_BITMAP_INTERPOLATION_MODE mode)
 567 {
 568     FIXME("iface %p, mode %#x stub!\n", iface, mode);
 569 }
 570
 571 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap *bitmap)
 572 {
 573     FIXME("iface %p, bitmap %p stub!\n", iface, bitmap);
 574 }
 575
 576 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush *iface)
 577 {
 578     FIXME("iface %p stub!\n", iface);
 579
 580     return D2D1_EXTEND_MODE_CLAMP;
 581 }
 582
 583 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush *iface)
 584 {
 585     FIXME("iface %p stub!\n", iface);
 586
 587     return D2D1_EXTEND_MODE_CLAMP;
 588 }
 589
 590 static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush *iface)
 591 {
 592     FIXME("iface %p stub!\n", iface);
 593
 594     return D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR;
 595 }
 596
 597 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap **bitmap)
 598 {
 599     FIXME("iface %p, bitmap %p stub!\n", iface, bitmap);
 600 }
 601
 602 static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl =
 603 {
 604     d2d_bitmap_brush_QueryInterface,
 605     d2d_bitmap_brush_AddRef,
 606     d2d_bitmap_brush_Release,
 607     d2d_bitmap_brush_GetFactory,
 608     d2d_bitmap_brush_SetOpacity,
 609     d2d_bitmap_brush_SetTransform,
 610     d2d_bitmap_brush_GetOpacity,
 611     d2d_bitmap_brush_GetTransform,
 612     d2d_bitmap_brush_SetExtendModeX,
 613     d2d_bitmap_brush_SetExtendModeY,
 614     d2d_bitmap_brush_SetInterpolationMode,
 615     d2d_bitmap_brush_SetBitmap,
 616     d2d_bitmap_brush_GetExtendModeX,
 617     d2d_bitmap_brush_GetExtendModeY,
 618     d2d_bitmap_brush_GetInterpolationMode,
 619     d2d_bitmap_brush_GetBitmap,
 620 };
 621
 622 HRESULT d2d_bitmap_brush_init(struct d2d_brush *brush, struct d2d_d3d_render_target *render_target, ID2D1Bitmap *bitmap,
 623         const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc)
 624 {
 625     D3D10_SAMPLER_DESC sampler_desc;
 626     HRESULT hr;
 627
 628     FIXME("Ignoring brush properties.\n");
 629
 630     d2d_brush_init(brush, &render_target->ID2D1RenderTarget_iface, D2D_BRUSH_TYPE_BITMAP,
 631             brush_desc, (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 632     brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap);
 633
 634     sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT;
 635     sampler_desc.AddressU = D3D10_TEXTURE_ADDRESS_CLAMP;
 636     sampler_desc.AddressV = D3D10_TEXTURE_ADDRESS_CLAMP;
 637     sampler_desc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP;
 638     sampler_desc.MipLODBias = 0.0f;
 639     sampler_desc.MaxAnisotropy = 0;
 640     sampler_desc.ComparisonFunc = D3D10_COMPARISON_NEVER;
 641     sampler_desc.BorderColor[0] = 0.0f;
 642     sampler_desc.BorderColor[1] = 0.0f;
 643     sampler_desc.BorderColor[2] = 0.0f;
 644     sampler_desc.BorderColor[3] = 0.0f;
 645     sampler_desc.MinLOD = 0.0f;
 646     sampler_desc.MaxLOD = 0.0f;
 647
 648     if (FAILED(hr = ID3D10Device_CreateSamplerState(render_target->device,
 649             &sampler_desc, &brush->u.bitmap.sampler_state)))
 650     {
 651         ERR("Failed to create sampler state, hr %#x.\n", hr);
 652         return hr;
 653     }
 654
 655     return S_OK;
 656 }
 657
 658 struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface)
 659 {
 660     if (!iface)
 661         return NULL;
 662     assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl
 663             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl
 664             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 665     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 666 }
 667
 668 void d2d_brush_bind_resources(struct d2d_brush *brush, ID3D10Device *device)
 669 {
 670     if (brush->type == D2D_BRUSH_TYPE_BITMAP)
 671     {
 672         ID3D10Device_PSSetShaderResources(device, 0, 1, &brush->u.bitmap.bitmap->view);
 673         ID3D10Device_PSSetSamplers(device, 0, 1, &brush->u.bitmap.sampler_state);
 674     }
 675 }