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         ID2D1Factory_Release(gradient->factory);
  72         HeapFree(GetProcessHeap(), 0, gradient);
  73     }
  74
  75     return refcount;
  76 }
  77
  78 static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory)
  79 {
  80     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  81
  82     TRACE("iface %p, factory %p.\n", iface, factory);
  83
  84     ID2D1Factory_AddRef(*factory = gradient->factory);
  85 }
  86
  87 static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface)
  88 {
  89     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  90
  91     TRACE("iface %p.\n", iface);
  92
  93     return gradient->stop_count;
  94 }
  95
  96 static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface,
  97         D2D1_GRADIENT_STOP *stops, UINT32 stop_count)
  98 {
  99     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
 100
 101     TRACE("iface %p, stops %p, stop_count %u.\n", iface, stops, stop_count);
 102
 103     memcpy(stops, gradient->stops, min(gradient->stop_count, stop_count) * sizeof(*stops));
 104     if (stop_count > gradient->stop_count)
 105         memset(stops, 0, (stop_count - gradient->stop_count) * sizeof(*stops));
 106 }
 107
 108 static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface)
 109 {
 110     FIXME("iface %p stub!\n", iface);
 111
 112     return D2D1_GAMMA_1_0;
 113 }
 114
 115 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface)
 116 {
 117     FIXME("iface %p stub!\n", iface);
 118
 119     return D2D1_EXTEND_MODE_CLAMP;
 120 }
 121
 122 static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl =
 123 {
 124     d2d_gradient_QueryInterface,
 125     d2d_gradient_AddRef,
 126     d2d_gradient_Release,
 127     d2d_gradient_GetFactory,
 128     d2d_gradient_GetGradientStopCount,
 129     d2d_gradient_GetGradientStops,
 130     d2d_gradient_GetColorInterpolationGamma,
 131     d2d_gradient_GetExtendMode,
 132 };
 133
 134 HRESULT d2d_gradient_init(struct d2d_gradient *gradient, ID2D1Factory *factory,
 135         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode)
 136 {
 137     FIXME("Ignoring gradient properties.\n");
 138
 139     gradient->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
 140     gradient->refcount = 1;
 141     ID2D1Factory_AddRef(gradient->factory = factory);
 142
 143     gradient->stop_count = stop_count;
 144     if (!(gradient->stops = HeapAlloc(GetProcessHeap(), 0, stop_count * sizeof(*stops))))
 145         return E_OUTOFMEMORY;
 146     memcpy(gradient->stops, stops, stop_count * sizeof(*stops));
 147
 148     return S_OK;
 149 }
 150
 151 static void d2d_brush_destroy(struct d2d_brush *brush)
 152 {
 153     ID2D1Factory_Release(brush->factory);
 154     HeapFree(GetProcessHeap(), 0, brush);
 155 }
 156
 157 static void d2d_brush_init(struct d2d_brush *brush, ID2D1Factory *factory,
 158         enum d2d_brush_type type, const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl)
 159 {
 160     static const D2D1_MATRIX_3X2_F identity =
 161     {
 162         1.0f, 0.0f,
 163         0.0f, 1.0f,
 164         0.0f, 0.0f,
 165     };
 166
 167     brush->ID2D1Brush_iface.lpVtbl = vtbl;
 168     brush->refcount = 1;
 169     ID2D1Factory_AddRef(brush->factory = factory);
 170     brush->opacity = desc ? desc->opacity : 1.0f;
 171     brush->transform = desc ? desc->transform : identity;
 172     brush->type = type;
 173 }
 174
 175 static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface)
 176 {
 177     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 178 }
 179
 180 static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface,
 181         REFIID iid, void **out)
 182 {
 183     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 184
 185     if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush)
 186             || IsEqualGUID(iid, &IID_ID2D1Brush)
 187             || IsEqualGUID(iid, &IID_ID2D1Resource)
 188             || IsEqualGUID(iid, &IID_IUnknown))
 189     {
 190         ID2D1SolidColorBrush_AddRef(iface);
 191         *out = iface;
 192         return S_OK;
 193     }
 194
 195     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 196
 197     *out = NULL;
 198     return E_NOINTERFACE;
 199 }
 200
 201 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface)
 202 {
 203     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 204     ULONG refcount = InterlockedIncrement(&brush->refcount);
 205
 206     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 207
 208     return refcount;
 209 }
 210
 211 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface)
 212 {
 213     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 214     ULONG refcount = InterlockedDecrement(&brush->refcount);
 215
 216     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 217
 218     if (!refcount)
 219         d2d_brush_destroy(brush);
 220
 221     return refcount;
 222 }
 223
 224 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory)
 225 {
 226     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 227
 228     TRACE("iface %p, factory %p.\n", iface, factory);
 229
 230     ID2D1Factory_AddRef(*factory = brush->factory);
 231 }
 232
 233 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity)
 234 {
 235     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 236
 237     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 238
 239     brush->opacity = opacity;
 240 }
 241
 242 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface,
 243         const D2D1_MATRIX_3X2_F *transform)
 244 {
 245     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 246
 247     TRACE("iface %p, transform %p.\n", iface, transform);
 248
 249     brush->transform = *transform;
 250 }
 251
 252 static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface)
 253 {
 254     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 255
 256     TRACE("iface %p.\n", iface);
 257
 258     return brush->opacity;
 259 }
 260
 261 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface,
 262         D2D1_MATRIX_3X2_F *transform)
 263 {
 264     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 265
 266     TRACE("iface %p, transform %p.\n", iface, transform);
 267
 268     *transform = brush->transform;
 269 }
 270
 271 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color)
 272 {
 273     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 274
 275     TRACE("iface %p, color %p.\n", iface, color);
 276
 277     brush->u.solid.color = *color;
 278 }
 279
 280 static D2D1_COLOR_F * STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface, D2D1_COLOR_F *color)
 281 {
 282     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 283
 284     TRACE("iface %p, color %p.\n", iface, color);
 285
 286     *color = brush->u.solid.color;
 287     return color;
 288 }
 289
 290 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 291 {
 292     d2d_solid_color_brush_QueryInterface,
 293     d2d_solid_color_brush_AddRef,
 294     d2d_solid_color_brush_Release,
 295     d2d_solid_color_brush_GetFactory,
 296     d2d_solid_color_brush_SetOpacity,
 297     d2d_solid_color_brush_SetTransform,
 298     d2d_solid_color_brush_GetOpacity,
 299     d2d_solid_color_brush_GetTransform,
 300     d2d_solid_color_brush_SetColor,
 301     d2d_solid_color_brush_GetColor,
 302 };
 303
 304 void d2d_solid_color_brush_init(struct d2d_brush *brush, ID2D1Factory *factory,
 305         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc)
 306 {
 307     d2d_brush_init(brush, factory, D2D_BRUSH_TYPE_SOLID, desc,
 308             (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 309     brush->u.solid.color = *color;
 310 }
 311
 312 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 313 {
 314     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 315 }
 316
 317 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 318         REFIID iid, void **out)
 319 {
 320     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 321
 322     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 323             || IsEqualGUID(iid, &IID_ID2D1Brush)
 324             || IsEqualGUID(iid, &IID_ID2D1Resource)
 325             || IsEqualGUID(iid, &IID_IUnknown))
 326     {
 327         ID2D1LinearGradientBrush_AddRef(iface);
 328         *out = iface;
 329         return S_OK;
 330     }
 331
 332     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 333
 334     *out = NULL;
 335     return E_NOINTERFACE;
 336 }
 337
 338 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 339 {
 340     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 341     ULONG refcount = InterlockedIncrement(&brush->refcount);
 342
 343     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 344
 345     return refcount;
 346 }
 347
 348 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 349 {
 350     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 351     ULONG refcount = InterlockedDecrement(&brush->refcount);
 352
 353     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 354
 355     if (!refcount)
 356         d2d_brush_destroy(brush);
 357
 358     return refcount;
 359 }
 360
 361 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 362         ID2D1Factory **factory)
 363 {
 364     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 365
 366     TRACE("iface %p, factory %p.\n", iface, factory);
 367
 368     ID2D1Factory_AddRef(*factory = brush->factory);
 369 }
 370
 371 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 372 {
 373     FIXME("iface %p, opacity %.8e stub!\n", iface, opacity);
 374 }
 375
 376 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 377         const D2D1_MATRIX_3X2_F *transform)
 378 {
 379     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 380
 381     TRACE("iface %p, transform %p.\n", iface, transform);
 382
 383     brush->transform = *transform;
 384 }
 385
 386 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 387 {
 388     FIXME("iface %p stub!\n", iface);
 389
 390     return 0.0f;
 391 }
 392
 393 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 394         D2D1_MATRIX_3X2_F *transform)
 395 {
 396     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 397
 398     TRACE("iface %p, transform %p.\n", iface, transform);
 399
 400     *transform = brush->transform;
 401 }
 402
 403 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 404         D2D1_POINT_2F start_point)
 405 {
 406     FIXME("iface %p, start_point {%.8e, %.8e} stub!\n", iface, start_point.x, start_point.y);
 407 }
 408
 409 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 410         D2D1_POINT_2F end_point)
 411 {
 412     FIXME("iface %p, end_point {%.8e, %.8e} stub!\n", iface, end_point.x, end_point.y);
 413 }
 414
 415 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface,
 416         D2D1_POINT_2F *point)
 417 {
 418     FIXME("iface %p, point %p stub!\n", iface, point);
 419
 420     point->x = 0.0f;
 421     point->y = 0.0f;
 422     return point;
 423 }
 424
 425 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface,
 426         D2D1_POINT_2F *point)
 427 {
 428     FIXME("iface %p, point %p stub!\n", iface, point);
 429
 430     point->x = 0.0f;
 431     point->y = 0.0f;
 432     return point;
 433 }
 434
 435 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 436         ID2D1GradientStopCollection **gradient)
 437 {
 438     FIXME("iface %p, gradient %p stub!\n", iface, gradient);
 439
 440     *gradient = NULL;
 441 }
 442
 443 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 444 {
 445     d2d_linear_gradient_brush_QueryInterface,
 446     d2d_linear_gradient_brush_AddRef,
 447     d2d_linear_gradient_brush_Release,
 448     d2d_linear_gradient_brush_GetFactory,
 449     d2d_linear_gradient_brush_SetOpacity,
 450     d2d_linear_gradient_brush_SetTransform,
 451     d2d_linear_gradient_brush_GetOpacity,
 452     d2d_linear_gradient_brush_GetTransform,
 453     d2d_linear_gradient_brush_SetStartPoint,
 454     d2d_linear_gradient_brush_SetEndPoint,
 455     d2d_linear_gradient_brush_GetStartPoint,
 456     d2d_linear_gradient_brush_GetEndPoint,
 457     d2d_linear_gradient_brush_GetGradientStopCollection,
 458 };
 459
 460 void d2d_linear_gradient_brush_init(struct d2d_brush *brush, ID2D1Factory *factory,
 461         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 462         ID2D1GradientStopCollection *gradient)
 463 {
 464     FIXME("Ignoring brush properties.\n");
 465
 466     d2d_brush_init(brush, factory, D2D_BRUSH_TYPE_LINEAR, brush_desc,
 467             (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl);
 468 }
 469
 470 static inline struct d2d_brush *impl_from_ID2D1BitmapBrush(ID2D1BitmapBrush *iface)
 471 {
 472     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 473 }
 474
 475 static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush *iface,
 476         REFIID iid, void **out)
 477 {
 478     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 479
 480     if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush)
 481             || IsEqualGUID(iid, &IID_ID2D1Brush)
 482             || IsEqualGUID(iid, &IID_ID2D1Resource)
 483             || IsEqualGUID(iid, &IID_IUnknown))
 484     {
 485         ID2D1BitmapBrush_AddRef(iface);
 486         *out = iface;
 487         return S_OK;
 488     }
 489
 490     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 491
 492     *out = NULL;
 493     return E_NOINTERFACE;
 494 }
 495
 496 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface)
 497 {
 498     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 499     ULONG refcount = InterlockedIncrement(&brush->refcount);
 500
 501     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 502
 503     return refcount;
 504 }
 505
 506 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface)
 507 {
 508     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 509     ULONG refcount = InterlockedDecrement(&brush->refcount);
 510
 511     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 512
 513     if (!refcount)
 514     {
 515         if (brush->u.bitmap.sampler_state)
 516             ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 517         if (brush->u.bitmap.bitmap)
 518             ID2D1Bitmap_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap_iface);
 519         d2d_brush_destroy(brush);
 520     }
 521
 522     return refcount;
 523 }
 524
 525 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush *iface,
 526         ID2D1Factory **factory)
 527 {
 528     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 529
 530     TRACE("iface %p, factory %p.\n", iface, factory);
 531
 532     ID2D1Factory_AddRef(*factory = brush->factory);
 533 }
 534
 535 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush *iface, float opacity)
 536 {
 537     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 538
 539     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 540
 541     brush->opacity = opacity;
 542 }
 543
 544 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush *iface,
 545         const D2D1_MATRIX_3X2_F *transform)
 546 {
 547     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 548
 549     TRACE("iface %p, transform %p.\n", iface, transform);
 550
 551     brush->transform = *transform;
 552 }
 553
 554 static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush *iface)
 555 {
 556     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 557
 558     TRACE("iface %p.\n", iface);
 559
 560     return brush->opacity;
 561 }
 562
 563 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush *iface,
 564         D2D1_MATRIX_3X2_F *transform)
 565 {
 566     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 567
 568     TRACE("iface %p, transform %p.\n", iface, transform);
 569
 570     *transform = brush->transform;
 571 }
 572
 573 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 574 {
 575     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 576
 577     TRACE("iface %p, mode %#x.\n", iface, mode);
 578
 579     brush->u.bitmap.extend_mode_x = mode;
 580     if (brush->u.bitmap.sampler_state)
 581     {
 582         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 583         brush->u.bitmap.sampler_state = NULL;
 584     }
 585 }
 586
 587 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 588 {
 589     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 590
 591     TRACE("iface %p, mode %#x.\n", iface, mode);
 592
 593     brush->u.bitmap.extend_mode_y = mode;
 594     if (brush->u.bitmap.sampler_state)
 595     {
 596         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 597         brush->u.bitmap.sampler_state = NULL;
 598     }
 599 }
 600
 601 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush *iface,
 602         D2D1_BITMAP_INTERPOLATION_MODE mode)
 603 {
 604     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 605
 606     TRACE("iface %p, mode %#x.\n", iface, mode);
 607
 608     brush->u.bitmap.interpolation_mode = mode;
 609     if (brush->u.bitmap.sampler_state)
 610     {
 611         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 612         brush->u.bitmap.sampler_state = NULL;
 613     }
 614 }
 615
 616 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap *bitmap)
 617 {
 618     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 619
 620     TRACE("iface %p, bitmap %p.\n", iface, bitmap);
 621
 622     if (bitmap)
 623         ID2D1Bitmap_AddRef(bitmap);
 624     if (brush->u.bitmap.bitmap)
 625         ID2D1Bitmap_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap_iface);
 626     brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap);
 627 }
 628
 629 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush *iface)
 630 {
 631     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 632
 633     TRACE("iface %p.\n", iface);
 634
 635     return brush->u.bitmap.extend_mode_x;
 636 }
 637
 638 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush *iface)
 639 {
 640     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 641
 642     TRACE("iface %p.\n", iface);
 643
 644     return brush->u.bitmap.extend_mode_y;
 645 }
 646
 647 static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush *iface)
 648 {
 649     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 650
 651     TRACE("iface %p.\n", iface);
 652
 653     return brush->u.bitmap.interpolation_mode;
 654 }
 655
 656 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap **bitmap)
 657 {
 658     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 659
 660     TRACE("iface %p, bitmap %p.\n", iface, bitmap);
 661
 662     if ((*bitmap = &brush->u.bitmap.bitmap->ID2D1Bitmap_iface))
 663         ID2D1Bitmap_AddRef(*bitmap);
 664 }
 665
 666 static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl =
 667 {
 668     d2d_bitmap_brush_QueryInterface,
 669     d2d_bitmap_brush_AddRef,
 670     d2d_bitmap_brush_Release,
 671     d2d_bitmap_brush_GetFactory,
 672     d2d_bitmap_brush_SetOpacity,
 673     d2d_bitmap_brush_SetTransform,
 674     d2d_bitmap_brush_GetOpacity,
 675     d2d_bitmap_brush_GetTransform,
 676     d2d_bitmap_brush_SetExtendModeX,
 677     d2d_bitmap_brush_SetExtendModeY,
 678     d2d_bitmap_brush_SetInterpolationMode,
 679     d2d_bitmap_brush_SetBitmap,
 680     d2d_bitmap_brush_GetExtendModeX,
 681     d2d_bitmap_brush_GetExtendModeY,
 682     d2d_bitmap_brush_GetInterpolationMode,
 683     d2d_bitmap_brush_GetBitmap,
 684 };
 685
 686 HRESULT d2d_bitmap_brush_init(struct d2d_brush *brush, ID2D1Factory *factory, ID2D1Bitmap *bitmap,
 687         const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc)
 688 {
 689     d2d_brush_init(brush, factory, D2D_BRUSH_TYPE_BITMAP,
 690             brush_desc, (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 691     if ((brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap)))
 692         ID2D1Bitmap_AddRef(&brush->u.bitmap.bitmap->ID2D1Bitmap_iface);
 693     if (bitmap_brush_desc)
 694     {
 695         brush->u.bitmap.extend_mode_x = bitmap_brush_desc->extendModeX;
 696         brush->u.bitmap.extend_mode_y = bitmap_brush_desc->extendModeY;
 697         brush->u.bitmap.interpolation_mode = bitmap_brush_desc->interpolationMode;
 698     }
 699     else
 700     {
 701         brush->u.bitmap.extend_mode_x = D2D1_EXTEND_MODE_CLAMP;
 702         brush->u.bitmap.extend_mode_y = D2D1_EXTEND_MODE_CLAMP;
 703         brush->u.bitmap.interpolation_mode = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR;
 704     }
 705
 706     return S_OK;
 707 }
 708
 709 struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface)
 710 {
 711     if (!iface)
 712         return NULL;
 713     assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl
 714             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl
 715             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
 716     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 717 }
 718
 719 static D3D10_TEXTURE_ADDRESS_MODE texture_address_mode_from_extend_mode(D2D1_EXTEND_MODE mode)
 720 {
 721     switch (mode)
 722     {
 723         case D2D1_EXTEND_MODE_CLAMP:
 724             return D3D10_TEXTURE_ADDRESS_CLAMP;
 725         case D2D1_EXTEND_MODE_WRAP:
 726             return D3D10_TEXTURE_ADDRESS_WRAP;
 727         case D2D1_EXTEND_MODE_MIRROR:
 728             return D3D10_TEXTURE_ADDRESS_MIRROR;
 729         default:
 730             FIXME("Unhandled extend mode %#x.\n", mode);
 731             return D3D10_TEXTURE_ADDRESS_CLAMP;
 732     }
 733 }
 734
 735 HRESULT d2d_brush_get_ps_cb(struct d2d_brush *brush, struct d2d_d3d_render_target *render_target,
 736         ID3D10Buffer **ps_cb)
 737 {
 738     D3D10_SUBRESOURCE_DATA buffer_data;
 739     D3D10_BUFFER_DESC buffer_desc;
 740     struct
 741     {
 742         float _11, _21, _31, pad0;
 743         float _12, _22, _32, opacity;
 744         BOOL ignore_alpha;
 745     } bitmap_brush_cb;
 746     D2D1_COLOR_F color;
 747     HRESULT hr;
 748
 749     buffer_desc.Usage = D3D10_USAGE_DEFAULT;
 750     buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
 751     buffer_desc.CPUAccessFlags = 0;
 752     buffer_desc.MiscFlags = 0;
 753
 754     buffer_data.SysMemPitch = 0;
 755     buffer_data.SysMemSlicePitch = 0;
 756
 757     if (brush->type == D2D_BRUSH_TYPE_SOLID)
 758     {
 759         color = brush->u.solid.color;
 760         color.a *= brush->opacity;
 761         color.r *= color.a;
 762         color.g *= color.a;
 763         color.b *= color.a;
 764
 765         buffer_desc.ByteWidth = sizeof(color);
 766         buffer_data.pSysMem = &color;
 767     }
 768     else if (brush->type == D2D_BRUSH_TYPE_BITMAP)
 769     {
 770         struct d2d_bitmap *bitmap = brush->u.bitmap.bitmap;
 771         D2D_MATRIX_3X2_F w, b;
 772         float dpi_scale, d;
 773
 774         /* Scale for dpi. */
 775         w = render_target->drawing_state.transform;
 776         dpi_scale = render_target->dpi_x / 96.0f;
 777         w._11 *= dpi_scale;
 778         w._21 *= dpi_scale;
 779         w._31 *= dpi_scale;
 780         dpi_scale = render_target->dpi_y / 96.0f;
 781         w._12 *= dpi_scale;
 782         w._22 *= dpi_scale;
 783         w._32 *= dpi_scale;
 784
 785         /* Scale for bitmap size and dpi. */
 786         b = brush->transform;
 787         dpi_scale = bitmap->pixel_size.width * (96.0f / bitmap->dpi_x);
 788         b._11 *= dpi_scale;
 789         b._21 *= dpi_scale;
 790         dpi_scale = bitmap->pixel_size.height * (96.0f / bitmap->dpi_y);
 791         b._12 *= dpi_scale;
 792         b._22 *= dpi_scale;
 793
 794         d2d_matrix_multiply(&b, &w);
 795
 796         /* Invert the matrix. (Because the matrix is applied to the sampling
 797          * coordinates. I.e., to scale the bitmap by 2 we need to divide the
 798          * coordinates by 2.) */
 799         d = b._11 * b._22 - b._21 * b._12;
 800         if (d != 0.0f)
 801         {
 802             bitmap_brush_cb._11 = b._22 / d;
 803             bitmap_brush_cb._21 = -b._21 / d;
 804             bitmap_brush_cb._31 = (b._21 * b._32 - b._31 * b._22) / d;
 805             bitmap_brush_cb._12 = -b._12 / d;
 806             bitmap_brush_cb._22 = b._11 / d;
 807             bitmap_brush_cb._32 = -(b._11 * b._32 - b._31 * b._12) / d;
 808         }
 809         bitmap_brush_cb.opacity = brush->opacity;
 810         bitmap_brush_cb.ignore_alpha = bitmap->format.alphaMode == D2D1_ALPHA_MODE_IGNORE;
 811
 812         buffer_desc.ByteWidth = sizeof(bitmap_brush_cb);
 813         buffer_data.pSysMem = &bitmap_brush_cb;
 814     }
 815     else
 816     {
 817         FIXME("Unhandled brush type %#x.\n", brush->type);
 818         return E_NOTIMPL;
 819     }
 820
 821     if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->device, &buffer_desc, &buffer_data, ps_cb)))
 822         ERR("Failed to create constant buffer, hr %#x.\n", hr);
 823
 824     return hr;
 825 }
 826
 827 void d2d_brush_bind_resources(struct d2d_brush *brush, struct d2d_d3d_render_target *render_target,
 828         enum d2d_shape_type shape_type)
 829 {
 830     static const float blend_factor[] = {1.0f, 1.0f, 1.0f, 1.0f};
 831     ID3D10Device *device = render_target->device;
 832     ID3D10PixelShader *ps;
 833     HRESULT hr;
 834
 835     ID3D10Device_OMSetBlendState(device, render_target->bs, blend_factor, D3D10_DEFAULT_SAMPLE_MASK);
 836     if (!(ps = render_target->shape_resources[shape_type].ps[brush->type]))
 837         FIXME("No pixel shader for shape type %#x and brush type %#x.\n", shape_type, brush->type);
 838     ID3D10Device_PSSetShader(device, ps);
 839
 840     if (brush->type == D2D_BRUSH_TYPE_BITMAP)
 841     {
 842         ID3D10Device_PSSetShaderResources(device, 0, 1, &brush->u.bitmap.bitmap->view);
 843         if (!brush->u.bitmap.sampler_state)
 844         {
 845             D3D10_SAMPLER_DESC sampler_desc;
 846
 847             if (brush->u.bitmap.interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR)
 848                 sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT;
 849             else
 850                 sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR;
 851             sampler_desc.AddressU = texture_address_mode_from_extend_mode(brush->u.bitmap.extend_mode_x);
 852             sampler_desc.AddressV = texture_address_mode_from_extend_mode(brush->u.bitmap.extend_mode_y);
 853             sampler_desc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP;
 854             sampler_desc.MipLODBias = 0.0f;
 855             sampler_desc.MaxAnisotropy = 0;
 856             sampler_desc.ComparisonFunc = D3D10_COMPARISON_NEVER;
 857             sampler_desc.BorderColor[0] = 0.0f;
 858             sampler_desc.BorderColor[1] = 0.0f;
 859             sampler_desc.BorderColor[2] = 0.0f;
 860             sampler_desc.BorderColor[3] = 0.0f;
 861             sampler_desc.MinLOD = 0.0f;
 862             sampler_desc.MaxLOD = 0.0f;
 863
 864             if (FAILED(hr = ID3D10Device_CreateSamplerState(device,
 865                     &sampler_desc, &brush->u.bitmap.sampler_state)))
 866                 ERR("Failed to create sampler state, hr %#x.\n", hr);
 867         }
 868         ID3D10Device_PSSetSamplers(device, 0, 1, &brush->u.bitmap.sampler_state);
 869     }
 870     else if (brush->type != D2D_BRUSH_TYPE_SOLID)
 871     {
 872         FIXME("Unhandled brush type %#x.\n", brush->type);
 873     }
 874 }