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         ID3D10ShaderResourceView_Release(gradient->view);
  72         ID2D1Factory_Release(gradient->factory);
  73         HeapFree(GetProcessHeap(), 0, gradient);
  74     }
  75
  76     return refcount;
  77 }
  78
  79 static void STDMETHODCALLTYPE d2d_gradient_GetFactory(ID2D1GradientStopCollection *iface, ID2D1Factory **factory)
  80 {
  81     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  82
  83     TRACE("iface %p, factory %p.\n", iface, factory);
  84
  85     ID2D1Factory_AddRef(*factory = gradient->factory);
  86 }
  87
  88 static UINT32 STDMETHODCALLTYPE d2d_gradient_GetGradientStopCount(ID2D1GradientStopCollection *iface)
  89 {
  90     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
  91
  92     TRACE("iface %p.\n", iface);
  93
  94     return gradient->stop_count;
  95 }
  96
  97 static void STDMETHODCALLTYPE d2d_gradient_GetGradientStops(ID2D1GradientStopCollection *iface,
  98         D2D1_GRADIENT_STOP *stops, UINT32 stop_count)
  99 {
 100     struct d2d_gradient *gradient = impl_from_ID2D1GradientStopCollection(iface);
 101
 102     TRACE("iface %p, stops %p, stop_count %u.\n", iface, stops, stop_count);
 103
 104     memcpy(stops, gradient->stops, min(gradient->stop_count, stop_count) * sizeof(*stops));
 105 }
 106
 107 static D2D1_GAMMA STDMETHODCALLTYPE d2d_gradient_GetColorInterpolationGamma(ID2D1GradientStopCollection *iface)
 108 {
 109     FIXME("iface %p stub!\n", iface);
 110
 111     return D2D1_GAMMA_1_0;
 112 }
 113
 114 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_gradient_GetExtendMode(ID2D1GradientStopCollection *iface)
 115 {
 116     FIXME("iface %p stub!\n", iface);
 117
 118     return D2D1_EXTEND_MODE_CLAMP;
 119 }
 120
 121 static const struct ID2D1GradientStopCollectionVtbl d2d_gradient_vtbl =
 122 {
 123     d2d_gradient_QueryInterface,
 124     d2d_gradient_AddRef,
 125     d2d_gradient_Release,
 126     d2d_gradient_GetFactory,
 127     d2d_gradient_GetGradientStopCount,
 128     d2d_gradient_GetGradientStops,
 129     d2d_gradient_GetColorInterpolationGamma,
 130     d2d_gradient_GetExtendMode,
 131 };
 132
 133 HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D10Device *device, const D2D1_GRADIENT_STOP *stops,
 134         UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode, struct d2d_gradient **gradient)
 135 {
 136     D3D10_SHADER_RESOURCE_VIEW_DESC srv_desc;
 137     D3D10_SUBRESOURCE_DATA buffer_data;
 138     ID3D10ShaderResourceView *view;
 139     D3D10_BUFFER_DESC buffer_desc;
 140     struct d2d_vec4 *data;
 141     ID3D10Buffer *buffer;
 142     unsigned int i;
 143     HRESULT hr;
 144
 145     if (!(data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 2 * stop_count * sizeof(*data))))
 146     {
 147         ERR("Failed to allocate data.\n");
 148         return E_OUTOFMEMORY;
 149     }
 150
 151     for (i = 0; i < stop_count; ++i)
 152     {
 153         data[i * 2].x = stops[i].position;
 154         data[i * 2 + 1].x = stops[i].color.r;
 155         data[i * 2 + 1].y = stops[i].color.g;
 156         data[i * 2 + 1].z = stops[i].color.b;
 157         data[i * 2 + 1].w = stops[i].color.a;
 158     }
 159
 160     buffer_desc.ByteWidth = 2 * stop_count * sizeof(*data);
 161     buffer_desc.Usage = D3D10_USAGE_DEFAULT;
 162     buffer_desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
 163     buffer_desc.CPUAccessFlags = 0;
 164     buffer_desc.MiscFlags = 0;
 165
 166     buffer_data.pSysMem = data;
 167     buffer_data.SysMemPitch = 0;
 168     buffer_data.SysMemSlicePitch = 0;
 169
 170     hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &buffer_data, &buffer);
 171     HeapFree(GetProcessHeap(), 0, data);
 172     if (FAILED(hr))
 173     {
 174         ERR("Failed to create buffer, hr %#x.\n", hr);
 175         return hr;
 176     }
 177
 178     srv_desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
 179     srv_desc.ViewDimension = D3D10_SRV_DIMENSION_BUFFER;
 180     srv_desc.Buffer.ElementOffset = 0;
 181     srv_desc.Buffer.ElementWidth = 2 * stop_count;
 182
 183     hr = ID3D10Device_CreateShaderResourceView(device, (ID3D10Resource *)buffer, &srv_desc, &view);
 184     ID3D10Buffer_Release(buffer);
 185     if (FAILED(hr))
 186     {
 187         ERR("Failed to create view, hr %#x.\n", hr);
 188         return hr;
 189     }
 190
 191     if (!(*gradient = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**gradient))))
 192     {
 193         ID3D10ShaderResourceView_Release(view);
 194         return E_OUTOFMEMORY;
 195     }
 196
 197     if (gamma != D2D1_GAMMA_2_2)
 198         FIXME("Ignoring gamma %#x.\n", gamma);
 199     if (extend_mode != D2D1_EXTEND_MODE_CLAMP)
 200         FIXME("Ignoring extend mode %#x.\n", extend_mode);
 201
 202     (*gradient)->ID2D1GradientStopCollection_iface.lpVtbl = &d2d_gradient_vtbl;
 203     (*gradient)->refcount = 1;
 204     ID2D1Factory_AddRef((*gradient)->factory = factory);
 205     (*gradient)->view = view;
 206
 207     (*gradient)->stop_count = stop_count;
 208     if (!((*gradient)->stops = HeapAlloc(GetProcessHeap(), 0, stop_count * sizeof(*stops))))
 209     {
 210         ID3D10ShaderResourceView_Release(view);
 211         HeapFree(GetProcessHeap(), 0, *gradient);
 212         return E_OUTOFMEMORY;
 213     }
 214     memcpy((*gradient)->stops, stops, stop_count * sizeof(*stops));
 215
 216     TRACE("Created gradient %p.\n", *gradient);
 217     return S_OK;
 218 }
 219
 220 static struct d2d_gradient *unsafe_impl_from_ID2D1GradientStopCollection(ID2D1GradientStopCollection *iface)
 221 {
 222     if (!iface)
 223         return NULL;
 224     assert(iface->lpVtbl == &d2d_gradient_vtbl);
 225     return CONTAINING_RECORD(iface, struct d2d_gradient, ID2D1GradientStopCollection_iface);
 226 }
 227
 228 static void d2d_brush_destroy(struct d2d_brush *brush)
 229 {
 230     ID2D1Factory_Release(brush->factory);
 231     HeapFree(GetProcessHeap(), 0, brush);
 232 }
 233
 234 static void d2d_brush_init(struct d2d_brush *brush, ID2D1Factory *factory,
 235         enum d2d_brush_type type, const D2D1_BRUSH_PROPERTIES *desc, const struct ID2D1BrushVtbl *vtbl)
 236 {
 237     static const D2D1_MATRIX_3X2_F identity =
 238     {
 239         1.0f, 0.0f,
 240         0.0f, 1.0f,
 241         0.0f, 0.0f,
 242     };
 243
 244     brush->ID2D1Brush_iface.lpVtbl = vtbl;
 245     brush->refcount = 1;
 246     ID2D1Factory_AddRef(brush->factory = factory);
 247     brush->opacity = desc ? desc->opacity : 1.0f;
 248     brush->transform = desc ? desc->transform : identity;
 249     brush->type = type;
 250 }
 251
 252 static inline struct d2d_brush *impl_from_ID2D1SolidColorBrush(ID2D1SolidColorBrush *iface)
 253 {
 254     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 255 }
 256
 257 static HRESULT STDMETHODCALLTYPE d2d_solid_color_brush_QueryInterface(ID2D1SolidColorBrush *iface,
 258         REFIID iid, void **out)
 259 {
 260     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 261
 262     if (IsEqualGUID(iid, &IID_ID2D1SolidColorBrush)
 263             || IsEqualGUID(iid, &IID_ID2D1Brush)
 264             || IsEqualGUID(iid, &IID_ID2D1Resource)
 265             || IsEqualGUID(iid, &IID_IUnknown))
 266     {
 267         ID2D1SolidColorBrush_AddRef(iface);
 268         *out = iface;
 269         return S_OK;
 270     }
 271
 272     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 273
 274     *out = NULL;
 275     return E_NOINTERFACE;
 276 }
 277
 278 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_AddRef(ID2D1SolidColorBrush *iface)
 279 {
 280     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 281     ULONG refcount = InterlockedIncrement(&brush->refcount);
 282
 283     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 284
 285     return refcount;
 286 }
 287
 288 static ULONG STDMETHODCALLTYPE d2d_solid_color_brush_Release(ID2D1SolidColorBrush *iface)
 289 {
 290     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 291     ULONG refcount = InterlockedDecrement(&brush->refcount);
 292
 293     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 294
 295     if (!refcount)
 296         d2d_brush_destroy(brush);
 297
 298     return refcount;
 299 }
 300
 301 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetFactory(ID2D1SolidColorBrush *iface, ID2D1Factory **factory)
 302 {
 303     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 304
 305     TRACE("iface %p, factory %p.\n", iface, factory);
 306
 307     ID2D1Factory_AddRef(*factory = brush->factory);
 308 }
 309
 310 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetOpacity(ID2D1SolidColorBrush *iface, float opacity)
 311 {
 312     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 313
 314     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 315
 316     brush->opacity = opacity;
 317 }
 318
 319 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetTransform(ID2D1SolidColorBrush *iface,
 320         const D2D1_MATRIX_3X2_F *transform)
 321 {
 322     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 323
 324     TRACE("iface %p, transform %p.\n", iface, transform);
 325
 326     brush->transform = *transform;
 327 }
 328
 329 static float STDMETHODCALLTYPE d2d_solid_color_brush_GetOpacity(ID2D1SolidColorBrush *iface)
 330 {
 331     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 332
 333     TRACE("iface %p.\n", iface);
 334
 335     return brush->opacity;
 336 }
 337
 338 static void STDMETHODCALLTYPE d2d_solid_color_brush_GetTransform(ID2D1SolidColorBrush *iface,
 339         D2D1_MATRIX_3X2_F *transform)
 340 {
 341     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 342
 343     TRACE("iface %p, transform %p.\n", iface, transform);
 344
 345     *transform = brush->transform;
 346 }
 347
 348 static void STDMETHODCALLTYPE d2d_solid_color_brush_SetColor(ID2D1SolidColorBrush *iface, const D2D1_COLOR_F *color)
 349 {
 350     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 351
 352     TRACE("iface %p, color %p.\n", iface, color);
 353
 354     brush->u.solid.color = *color;
 355 }
 356
 357 static D2D1_COLOR_F * STDMETHODCALLTYPE d2d_solid_color_brush_GetColor(ID2D1SolidColorBrush *iface, D2D1_COLOR_F *color)
 358 {
 359     struct d2d_brush *brush = impl_from_ID2D1SolidColorBrush(iface);
 360
 361     TRACE("iface %p, color %p.\n", iface, color);
 362
 363     *color = brush->u.solid.color;
 364     return color;
 365 }
 366
 367 static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
 368 {
 369     d2d_solid_color_brush_QueryInterface,
 370     d2d_solid_color_brush_AddRef,
 371     d2d_solid_color_brush_Release,
 372     d2d_solid_color_brush_GetFactory,
 373     d2d_solid_color_brush_SetOpacity,
 374     d2d_solid_color_brush_SetTransform,
 375     d2d_solid_color_brush_GetOpacity,
 376     d2d_solid_color_brush_GetTransform,
 377     d2d_solid_color_brush_SetColor,
 378     d2d_solid_color_brush_GetColor,
 379 };
 380
 381 HRESULT d2d_solid_color_brush_create(ID2D1Factory *factory, const D2D1_COLOR_F *color,
 382         const D2D1_BRUSH_PROPERTIES *desc, struct d2d_brush **brush)
 383 {
 384     if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
 385         return E_OUTOFMEMORY;
 386
 387     d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_SOLID, desc,
 388             (ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl);
 389     (*brush)->u.solid.color = *color;
 390
 391     TRACE("Created brush %p.\n", *brush);
 392     return S_OK;
 393 }
 394
 395 static inline struct d2d_brush *impl_from_ID2D1LinearGradientBrush(ID2D1LinearGradientBrush *iface)
 396 {
 397     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 398 }
 399
 400 static HRESULT STDMETHODCALLTYPE d2d_linear_gradient_brush_QueryInterface(ID2D1LinearGradientBrush *iface,
 401         REFIID iid, void **out)
 402 {
 403     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 404
 405     if (IsEqualGUID(iid, &IID_ID2D1LinearGradientBrush)
 406             || IsEqualGUID(iid, &IID_ID2D1Brush)
 407             || IsEqualGUID(iid, &IID_ID2D1Resource)
 408             || IsEqualGUID(iid, &IID_IUnknown))
 409     {
 410         ID2D1LinearGradientBrush_AddRef(iface);
 411         *out = iface;
 412         return S_OK;
 413     }
 414
 415     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 416
 417     *out = NULL;
 418     return E_NOINTERFACE;
 419 }
 420
 421 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_AddRef(ID2D1LinearGradientBrush *iface)
 422 {
 423     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 424     ULONG refcount = InterlockedIncrement(&brush->refcount);
 425
 426     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 427
 428     return refcount;
 429 }
 430
 431 static ULONG STDMETHODCALLTYPE d2d_linear_gradient_brush_Release(ID2D1LinearGradientBrush *iface)
 432 {
 433     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 434     ULONG refcount = InterlockedDecrement(&brush->refcount);
 435
 436     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 437
 438     if (!refcount)
 439     {
 440         ID2D1GradientStopCollection_Release(&brush->u.linear.gradient->ID2D1GradientStopCollection_iface);
 441         d2d_brush_destroy(brush);
 442     }
 443
 444     return refcount;
 445 }
 446
 447 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetFactory(ID2D1LinearGradientBrush *iface,
 448         ID2D1Factory **factory)
 449 {
 450     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 451
 452     TRACE("iface %p, factory %p.\n", iface, factory);
 453
 454     ID2D1Factory_AddRef(*factory = brush->factory);
 455 }
 456
 457 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetOpacity(ID2D1LinearGradientBrush *iface, float opacity)
 458 {
 459     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 460
 461     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 462
 463     brush->opacity = opacity;
 464 }
 465
 466 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetTransform(ID2D1LinearGradientBrush *iface,
 467         const D2D1_MATRIX_3X2_F *transform)
 468 {
 469     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 470
 471     TRACE("iface %p, transform %p.\n", iface, transform);
 472
 473     brush->transform = *transform;
 474 }
 475
 476 static float STDMETHODCALLTYPE d2d_linear_gradient_brush_GetOpacity(ID2D1LinearGradientBrush *iface)
 477 {
 478     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 479
 480     TRACE("iface %p.\n", iface);
 481
 482     return brush->opacity;
 483 }
 484
 485 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetTransform(ID2D1LinearGradientBrush *iface,
 486         D2D1_MATRIX_3X2_F *transform)
 487 {
 488     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 489
 490     TRACE("iface %p, transform %p.\n", iface, transform);
 491
 492     *transform = brush->transform;
 493 }
 494
 495 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetStartPoint(ID2D1LinearGradientBrush *iface,
 496         D2D1_POINT_2F start_point)
 497 {
 498     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 499
 500     TRACE("iface %p, start_point {%.8e, %.8e}.\n", iface, start_point.x, start_point.y);
 501
 502     brush->u.linear.start = start_point;
 503 }
 504
 505 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_SetEndPoint(ID2D1LinearGradientBrush *iface,
 506         D2D1_POINT_2F end_point)
 507 {
 508     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 509
 510     TRACE("iface %p, end_point {%.8e, %.8e}.\n", iface, end_point.x, end_point.y);
 511
 512     brush->u.linear.end = end_point;
 513 }
 514
 515 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetStartPoint(ID2D1LinearGradientBrush *iface,
 516         D2D1_POINT_2F *point)
 517 {
 518     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 519
 520     TRACE("iface %p, point %p.\n", iface, point);
 521
 522     *point = brush->u.linear.start;
 523     return point;
 524 }
 525
 526 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_linear_gradient_brush_GetEndPoint(ID2D1LinearGradientBrush *iface,
 527         D2D1_POINT_2F *point)
 528 {
 529     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 530
 531     TRACE("iface %p, point %p.\n", iface, point);
 532
 533     *point = brush->u.linear.end;
 534     return point;
 535 }
 536
 537 static void STDMETHODCALLTYPE d2d_linear_gradient_brush_GetGradientStopCollection(ID2D1LinearGradientBrush *iface,
 538         ID2D1GradientStopCollection **gradient)
 539 {
 540     struct d2d_brush *brush = impl_from_ID2D1LinearGradientBrush(iface);
 541
 542     TRACE("iface %p, gradient %p.\n", iface, gradient);
 543
 544     ID2D1GradientStopCollection_AddRef(*gradient = &brush->u.linear.gradient->ID2D1GradientStopCollection_iface);
 545 }
 546
 547 static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl =
 548 {
 549     d2d_linear_gradient_brush_QueryInterface,
 550     d2d_linear_gradient_brush_AddRef,
 551     d2d_linear_gradient_brush_Release,
 552     d2d_linear_gradient_brush_GetFactory,
 553     d2d_linear_gradient_brush_SetOpacity,
 554     d2d_linear_gradient_brush_SetTransform,
 555     d2d_linear_gradient_brush_GetOpacity,
 556     d2d_linear_gradient_brush_GetTransform,
 557     d2d_linear_gradient_brush_SetStartPoint,
 558     d2d_linear_gradient_brush_SetEndPoint,
 559     d2d_linear_gradient_brush_GetStartPoint,
 560     d2d_linear_gradient_brush_GetEndPoint,
 561     d2d_linear_gradient_brush_GetGradientStopCollection,
 562 };
 563
 564 HRESULT d2d_linear_gradient_brush_create(ID2D1Factory *factory, const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc,
 565         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
 566 {
 567     if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
 568         return E_OUTOFMEMORY;
 569
 570     d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_LINEAR, brush_desc,
 571             (ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl);
 572     (*brush)->u.linear.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient);
 573     ID2D1GradientStopCollection_AddRef(&(*brush)->u.linear.gradient->ID2D1GradientStopCollection_iface);
 574     (*brush)->u.linear.start = gradient_brush_desc->startPoint;
 575     (*brush)->u.linear.end = gradient_brush_desc->endPoint;
 576
 577     TRACE("Created brush %p.\n", *brush);
 578     return S_OK;
 579 }
 580
 581 static inline struct d2d_brush *impl_from_ID2D1RadialGradientBrush(ID2D1RadialGradientBrush *iface)
 582 {
 583     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 584 }
 585
 586 static HRESULT STDMETHODCALLTYPE d2d_radial_gradient_brush_QueryInterface(ID2D1RadialGradientBrush *iface,
 587         REFIID iid, void **out)
 588 {
 589     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 590
 591     if (IsEqualGUID(iid, &IID_ID2D1RadialGradientBrush)
 592             || IsEqualGUID(iid, &IID_ID2D1Brush)
 593             || IsEqualGUID(iid, &IID_ID2D1Resource)
 594             || IsEqualGUID(iid, &IID_IUnknown))
 595     {
 596         ID2D1RadialGradientBrush_AddRef(iface);
 597         *out = iface;
 598         return S_OK;
 599     }
 600
 601     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 602
 603     *out = NULL;
 604     return E_NOINTERFACE;
 605 }
 606
 607 static ULONG STDMETHODCALLTYPE d2d_radial_gradient_brush_AddRef(ID2D1RadialGradientBrush *iface)
 608 {
 609     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 610     ULONG refcount = InterlockedIncrement(&brush->refcount);
 611
 612     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 613
 614     return refcount;
 615 }
 616
 617 static ULONG STDMETHODCALLTYPE d2d_radial_gradient_brush_Release(ID2D1RadialGradientBrush *iface)
 618 {
 619     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 620     ULONG refcount = InterlockedDecrement(&brush->refcount);
 621
 622     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 623
 624     if (!refcount)
 625     {
 626         ID2D1GradientStopCollection_Release(&brush->u.radial.gradient->ID2D1GradientStopCollection_iface);
 627         d2d_brush_destroy(brush);
 628     }
 629
 630     return refcount;
 631 }
 632
 633 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetFactory(ID2D1RadialGradientBrush *iface,
 634         ID2D1Factory **factory)
 635 {
 636     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 637
 638     TRACE("iface %p, factory %p.\n", iface, factory);
 639
 640     ID2D1Factory_AddRef(*factory = brush->factory);
 641 }
 642
 643 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetOpacity(ID2D1RadialGradientBrush *iface, float opacity)
 644 {
 645     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 646
 647     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 648
 649     brush->opacity = opacity;
 650 }
 651
 652 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetTransform(ID2D1RadialGradientBrush *iface,
 653         const D2D1_MATRIX_3X2_F *transform)
 654 {
 655     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 656
 657     TRACE("iface %p, transform %p.\n", iface, transform);
 658
 659     brush->transform = *transform;
 660 }
 661
 662 static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetOpacity(ID2D1RadialGradientBrush *iface)
 663 {
 664     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 665
 666     TRACE("iface %p.\n", iface);
 667
 668     return brush->opacity;
 669 }
 670
 671 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetTransform(ID2D1RadialGradientBrush *iface,
 672         D2D1_MATRIX_3X2_F *transform)
 673 {
 674     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 675
 676     TRACE("iface %p, transform %p.\n", iface, transform);
 677
 678     *transform = brush->transform;
 679 }
 680
 681 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetCenter(ID2D1RadialGradientBrush *iface,
 682         D2D1_POINT_2F centre)
 683 {
 684     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 685
 686     TRACE("iface %p, centre {%.8e, %.8e}.\n", iface, centre.x, centre.y);
 687
 688     brush->u.radial.centre = centre;
 689 }
 690
 691 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetGradientOriginOffset(ID2D1RadialGradientBrush *iface,
 692         D2D1_POINT_2F offset)
 693 {
 694     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 695
 696     TRACE("iface %p, offset {%.8e, %.8e}.\n", iface, offset.x, offset.y);
 697
 698     brush->u.radial.offset = offset;
 699 }
 700
 701 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetRadiusX(ID2D1RadialGradientBrush *iface, float radius)
 702 {
 703     FIXME("iface %p, radius %.8e stub!\n", iface, radius);
 704 }
 705
 706 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_SetRadiusY(ID2D1RadialGradientBrush *iface, float radius)
 707 {
 708     FIXME("iface %p, radius %.8e stub!\n", iface, radius);
 709 }
 710
 711 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_radial_gradient_brush_GetCenter(ID2D1RadialGradientBrush *iface,
 712         D2D1_POINT_2F *centre)
 713 {
 714     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 715
 716     TRACE("iface %p, centre %p.\n", iface, centre);
 717
 718     *centre = brush->u.radial.centre;
 719     return centre;
 720 }
 721
 722 static D2D1_POINT_2F * STDMETHODCALLTYPE d2d_radial_gradient_brush_GetGradientOriginOffset(
 723         ID2D1RadialGradientBrush *iface, D2D1_POINT_2F *offset)
 724 {
 725     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 726
 727     TRACE("iface %p, offset %p.\n", iface, offset);
 728
 729     *offset = brush->u.radial.offset;
 730     return offset;
 731 }
 732
 733 static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetRadiusX(ID2D1RadialGradientBrush *iface)
 734 {
 735     FIXME("iface %p stub!\n", iface);
 736
 737     return 0.0f;
 738 }
 739
 740 static float STDMETHODCALLTYPE d2d_radial_gradient_brush_GetRadiusY(ID2D1RadialGradientBrush *iface)
 741 {
 742     FIXME("iface %p stub!\n", iface);
 743
 744     return 0.0f;
 745 }
 746
 747 static void STDMETHODCALLTYPE d2d_radial_gradient_brush_GetGradientStopCollection(ID2D1RadialGradientBrush *iface,
 748         ID2D1GradientStopCollection **gradient)
 749 {
 750     struct d2d_brush *brush = impl_from_ID2D1RadialGradientBrush(iface);
 751
 752     TRACE("iface %p, gradient %p.\n", iface, gradient);
 753
 754     ID2D1GradientStopCollection_AddRef(*gradient = &brush->u.radial.gradient->ID2D1GradientStopCollection_iface);
 755 }
 756
 757 static const struct ID2D1RadialGradientBrushVtbl d2d_radial_gradient_brush_vtbl =
 758 {
 759     d2d_radial_gradient_brush_QueryInterface,
 760     d2d_radial_gradient_brush_AddRef,
 761     d2d_radial_gradient_brush_Release,
 762     d2d_radial_gradient_brush_GetFactory,
 763     d2d_radial_gradient_brush_SetOpacity,
 764     d2d_radial_gradient_brush_SetTransform,
 765     d2d_radial_gradient_brush_GetOpacity,
 766     d2d_radial_gradient_brush_GetTransform,
 767     d2d_radial_gradient_brush_SetCenter,
 768     d2d_radial_gradient_brush_SetGradientOriginOffset,
 769     d2d_radial_gradient_brush_SetRadiusX,
 770     d2d_radial_gradient_brush_SetRadiusY,
 771     d2d_radial_gradient_brush_GetCenter,
 772     d2d_radial_gradient_brush_GetGradientOriginOffset,
 773     d2d_radial_gradient_brush_GetRadiusX,
 774     d2d_radial_gradient_brush_GetRadiusY,
 775     d2d_radial_gradient_brush_GetGradientStopCollection,
 776 };
 777
 778 HRESULT d2d_radial_gradient_brush_create(ID2D1Factory *factory,
 779         const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 780         ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
 781 {
 782     struct d2d_brush *b;
 783
 784     if (!(b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*b))))
 785         return E_OUTOFMEMORY;
 786
 787     d2d_brush_init(b, factory, D2D_BRUSH_TYPE_RADIAL, brush_desc, (ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl);
 788     b->u.radial.gradient = unsafe_impl_from_ID2D1GradientStopCollection(gradient);
 789     ID2D1GradientStopCollection_AddRef(&b->u.radial.gradient->ID2D1GradientStopCollection_iface);
 790     b->u.radial.centre = gradient_desc->center;
 791     b->u.radial.offset = gradient_desc->gradientOriginOffset;
 792
 793     TRACE("Created brush %p.\n", b);
 794     *brush = b;
 795
 796     return S_OK;
 797 }
 798
 799 static inline struct d2d_brush *impl_from_ID2D1BitmapBrush(ID2D1BitmapBrush *iface)
 800 {
 801     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
 802 }
 803
 804 static HRESULT STDMETHODCALLTYPE d2d_bitmap_brush_QueryInterface(ID2D1BitmapBrush *iface,
 805         REFIID iid, void **out)
 806 {
 807     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 808
 809     if (IsEqualGUID(iid, &IID_ID2D1BitmapBrush)
 810             || IsEqualGUID(iid, &IID_ID2D1Brush)
 811             || IsEqualGUID(iid, &IID_ID2D1Resource)
 812             || IsEqualGUID(iid, &IID_IUnknown))
 813     {
 814         ID2D1BitmapBrush_AddRef(iface);
 815         *out = iface;
 816         return S_OK;
 817     }
 818
 819     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 820
 821     *out = NULL;
 822     return E_NOINTERFACE;
 823 }
 824
 825 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_AddRef(ID2D1BitmapBrush *iface)
 826 {
 827     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 828     ULONG refcount = InterlockedIncrement(&brush->refcount);
 829
 830     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 831
 832     return refcount;
 833 }
 834
 835 static ULONG STDMETHODCALLTYPE d2d_bitmap_brush_Release(ID2D1BitmapBrush *iface)
 836 {
 837     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 838     ULONG refcount = InterlockedDecrement(&brush->refcount);
 839
 840     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 841
 842     if (!refcount)
 843     {
 844         if (brush->u.bitmap.sampler_state)
 845             ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 846         if (brush->u.bitmap.bitmap)
 847             ID2D1Bitmap_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap_iface);
 848         d2d_brush_destroy(brush);
 849     }
 850
 851     return refcount;
 852 }
 853
 854 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetFactory(ID2D1BitmapBrush *iface,
 855         ID2D1Factory **factory)
 856 {
 857     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 858
 859     TRACE("iface %p, factory %p.\n", iface, factory);
 860
 861     ID2D1Factory_AddRef(*factory = brush->factory);
 862 }
 863
 864 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetOpacity(ID2D1BitmapBrush *iface, float opacity)
 865 {
 866     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 867
 868     TRACE("iface %p, opacity %.8e.\n", iface, opacity);
 869
 870     brush->opacity = opacity;
 871 }
 872
 873 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetTransform(ID2D1BitmapBrush *iface,
 874         const D2D1_MATRIX_3X2_F *transform)
 875 {
 876     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 877
 878     TRACE("iface %p, transform %p.\n", iface, transform);
 879
 880     brush->transform = *transform;
 881 }
 882
 883 static float STDMETHODCALLTYPE d2d_bitmap_brush_GetOpacity(ID2D1BitmapBrush *iface)
 884 {
 885     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 886
 887     TRACE("iface %p.\n", iface);
 888
 889     return brush->opacity;
 890 }
 891
 892 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetTransform(ID2D1BitmapBrush *iface,
 893         D2D1_MATRIX_3X2_F *transform)
 894 {
 895     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 896
 897     TRACE("iface %p, transform %p.\n", iface, transform);
 898
 899     *transform = brush->transform;
 900 }
 901
 902 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeX(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 903 {
 904     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 905
 906     TRACE("iface %p, mode %#x.\n", iface, mode);
 907
 908     brush->u.bitmap.extend_mode_x = mode;
 909     if (brush->u.bitmap.sampler_state)
 910     {
 911         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 912         brush->u.bitmap.sampler_state = NULL;
 913     }
 914 }
 915
 916 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetExtendModeY(ID2D1BitmapBrush *iface, D2D1_EXTEND_MODE mode)
 917 {
 918     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 919
 920     TRACE("iface %p, mode %#x.\n", iface, mode);
 921
 922     brush->u.bitmap.extend_mode_y = mode;
 923     if (brush->u.bitmap.sampler_state)
 924     {
 925         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 926         brush->u.bitmap.sampler_state = NULL;
 927     }
 928 }
 929
 930 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetInterpolationMode(ID2D1BitmapBrush *iface,
 931         D2D1_BITMAP_INTERPOLATION_MODE mode)
 932 {
 933     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 934
 935     TRACE("iface %p, mode %#x.\n", iface, mode);
 936
 937     brush->u.bitmap.interpolation_mode = mode;
 938     if (brush->u.bitmap.sampler_state)
 939     {
 940         ID3D10SamplerState_Release(brush->u.bitmap.sampler_state);
 941         brush->u.bitmap.sampler_state = NULL;
 942     }
 943 }
 944
 945 static void STDMETHODCALLTYPE d2d_bitmap_brush_SetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap *bitmap)
 946 {
 947     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 948
 949     TRACE("iface %p, bitmap %p.\n", iface, bitmap);
 950
 951     if (bitmap)
 952         ID2D1Bitmap_AddRef(bitmap);
 953     if (brush->u.bitmap.bitmap)
 954         ID2D1Bitmap_Release(&brush->u.bitmap.bitmap->ID2D1Bitmap_iface);
 955     brush->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap);
 956 }
 957
 958 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeX(ID2D1BitmapBrush *iface)
 959 {
 960     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 961
 962     TRACE("iface %p.\n", iface);
 963
 964     return brush->u.bitmap.extend_mode_x;
 965 }
 966
 967 static D2D1_EXTEND_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetExtendModeY(ID2D1BitmapBrush *iface)
 968 {
 969     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 970
 971     TRACE("iface %p.\n", iface);
 972
 973     return brush->u.bitmap.extend_mode_y;
 974 }
 975
 976 static D2D1_BITMAP_INTERPOLATION_MODE STDMETHODCALLTYPE d2d_bitmap_brush_GetInterpolationMode(ID2D1BitmapBrush *iface)
 977 {
 978     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 979
 980     TRACE("iface %p.\n", iface);
 981
 982     return brush->u.bitmap.interpolation_mode;
 983 }
 984
 985 static void STDMETHODCALLTYPE d2d_bitmap_brush_GetBitmap(ID2D1BitmapBrush *iface, ID2D1Bitmap **bitmap)
 986 {
 987     struct d2d_brush *brush = impl_from_ID2D1BitmapBrush(iface);
 988
 989     TRACE("iface %p, bitmap %p.\n", iface, bitmap);
 990
 991     if ((*bitmap = &brush->u.bitmap.bitmap->ID2D1Bitmap_iface))
 992         ID2D1Bitmap_AddRef(*bitmap);
 993 }
 994
 995 static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl =
 996 {
 997     d2d_bitmap_brush_QueryInterface,
 998     d2d_bitmap_brush_AddRef,
 999     d2d_bitmap_brush_Release,
1000     d2d_bitmap_brush_GetFactory,
1001     d2d_bitmap_brush_SetOpacity,
1002     d2d_bitmap_brush_SetTransform,
1003     d2d_bitmap_brush_GetOpacity,
1004     d2d_bitmap_brush_GetTransform,
1005     d2d_bitmap_brush_SetExtendModeX,
1006     d2d_bitmap_brush_SetExtendModeY,
1007     d2d_bitmap_brush_SetInterpolationMode,
1008     d2d_bitmap_brush_SetBitmap,
1009     d2d_bitmap_brush_GetExtendModeX,
1010     d2d_bitmap_brush_GetExtendModeY,
1011     d2d_bitmap_brush_GetInterpolationMode,
1012     d2d_bitmap_brush_GetBitmap,
1013 };
1014
1015 HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc,
1016         const D2D1_BRUSH_PROPERTIES *brush_desc, struct d2d_brush **brush)
1017 {
1018     if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
1019         return E_OUTOFMEMORY;
1020
1021     d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_BITMAP,
1022             brush_desc, (ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
1023     if (((*brush)->u.bitmap.bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap)))
1024         ID2D1Bitmap_AddRef(&(*brush)->u.bitmap.bitmap->ID2D1Bitmap_iface);
1025     if (bitmap_brush_desc)
1026     {
1027         (*brush)->u.bitmap.extend_mode_x = bitmap_brush_desc->extendModeX;
1028         (*brush)->u.bitmap.extend_mode_y = bitmap_brush_desc->extendModeY;
1029         (*brush)->u.bitmap.interpolation_mode = bitmap_brush_desc->interpolationMode;
1030     }
1031     else
1032     {
1033         (*brush)->u.bitmap.extend_mode_x = D2D1_EXTEND_MODE_CLAMP;
1034         (*brush)->u.bitmap.extend_mode_y = D2D1_EXTEND_MODE_CLAMP;
1035         (*brush)->u.bitmap.interpolation_mode = D2D1_BITMAP_INTERPOLATION_MODE_LINEAR;
1036     }
1037
1038     TRACE("Created brush %p.\n", *brush);
1039     return S_OK;
1040 }
1041
1042 struct d2d_brush *unsafe_impl_from_ID2D1Brush(ID2D1Brush *iface)
1043 {
1044     if (!iface)
1045         return NULL;
1046     assert(iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_solid_color_brush_vtbl
1047             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_linear_gradient_brush_vtbl
1048             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl
1049             || iface->lpVtbl == (const ID2D1BrushVtbl *)&d2d_bitmap_brush_vtbl);
1050     return CONTAINING_RECORD(iface, struct d2d_brush, ID2D1Brush_iface);
1051 }
1052
1053 static D3D10_TEXTURE_ADDRESS_MODE texture_address_mode_from_extend_mode(D2D1_EXTEND_MODE mode)
1054 {
1055     switch (mode)
1056     {
1057         case D2D1_EXTEND_MODE_CLAMP:
1058             return D3D10_TEXTURE_ADDRESS_CLAMP;
1059         case D2D1_EXTEND_MODE_WRAP:
1060             return D3D10_TEXTURE_ADDRESS_WRAP;
1061         case D2D1_EXTEND_MODE_MIRROR:
1062             return D3D10_TEXTURE_ADDRESS_MIRROR;
1063         default:
1064             FIXME("Unhandled extend mode %#x.\n", mode);
1065             return D3D10_TEXTURE_ADDRESS_CLAMP;
1066     }
1067 }
1068
1069 static BOOL d2d_brush_fill_cb(const struct d2d_brush *brush,
1070         const struct d2d_d3d_render_target *render_target, struct d2d_brush_cb *cb)
1071 {
1072     struct d2d_bitmap *bitmap;
1073     D2D1_COLOR_F *colour;
1074     D2D_MATRIX_3X2_F b;
1075     float dpi_scale, d;
1076
1077     if (!brush)
1078     {
1079         cb->type = D2D_BRUSH_TYPE_COUNT;
1080         return TRUE;
1081     }
1082
1083     cb->type = brush->type;
1084     cb->opacity = brush->opacity;
1085
1086     switch (brush->type)
1087     {
1088         case D2D_BRUSH_TYPE_SOLID:
1089             colour = &cb->u.solid.colour;
1090
1091             *colour = brush->u.solid.color;
1092             colour->r *= colour->a;
1093             colour->g *= colour->a;
1094             colour->b *= colour->a;
1095
1096             return TRUE;
1097
1098         case D2D_BRUSH_TYPE_LINEAR:
1099             b = brush->transform;
1100             d2d_point_transform(&cb->u.linear.start, &b, brush->u.linear.start.x, brush->u.linear.start.y);
1101             d2d_point_transform(&cb->u.linear.end, &b, brush->u.linear.end.x, brush->u.linear.end.y);
1102             cb->u.linear.stop_count = brush->u.linear.gradient->stop_count;
1103
1104             return TRUE;
1105
1106         case D2D_BRUSH_TYPE_BITMAP:
1107             bitmap = brush->u.bitmap.bitmap;
1108
1109             /* Scale for bitmap size and dpi. */
1110             b = brush->transform;
1111             dpi_scale = bitmap->pixel_size.width * (96.0f / bitmap->dpi_x);
1112             b._11 *= dpi_scale;
1113             b._21 *= dpi_scale;
1114             dpi_scale = bitmap->pixel_size.height * (96.0f / bitmap->dpi_y);
1115             b._12 *= dpi_scale;
1116             b._22 *= dpi_scale;
1117
1118             /* Invert the matrix. (Because the matrix is applied to the
1119              * sampling coordinates. I.e., to scale the bitmap by 2 we need to
1120              * divide the coordinates by 2.) */
1121             d = b._11 * b._22 - b._21 * b._12;
1122             if (d != 0.0f)
1123             {
1124                 cb->u.bitmap._11 = b._22 / d;
1125                 cb->u.bitmap._21 = -b._21 / d;
1126                 cb->u.bitmap._31 = (b._21 * b._32 - b._31 * b._22) / d;
1127                 cb->u.bitmap._12 = -b._12 / d;
1128                 cb->u.bitmap._22 = b._11 / d;
1129                 cb->u.bitmap._32 = -(b._11 * b._32 - b._31 * b._12) / d;
1130             }
1131
1132             cb->u.bitmap.ignore_alpha = bitmap->format.alphaMode == D2D1_ALPHA_MODE_IGNORE;
1133
1134             return TRUE;
1135
1136         default:
1137             FIXME("Unhandled brush type %#x.\n", brush->type);
1138             return FALSE;
1139     }
1140 }
1141
1142 HRESULT d2d_brush_get_ps_cb(struct d2d_brush *brush, struct d2d_brush *opacity_brush,
1143         BOOL outline, struct d2d_d3d_render_target *render_target, ID3D10Buffer **ps_cb)
1144 {
1145     D3D10_SUBRESOURCE_DATA buffer_data;
1146     struct d2d_ps_cb cb_data = {0};
1147     D3D10_BUFFER_DESC buffer_desc;
1148     HRESULT hr;
1149
1150     cb_data.outline = outline;
1151     if (!d2d_brush_fill_cb(brush, render_target, &cb_data.colour_brush))
1152         return E_NOTIMPL;
1153     if (!d2d_brush_fill_cb(opacity_brush, render_target, &cb_data.opacity_brush))
1154         return E_NOTIMPL;
1155
1156     buffer_desc.ByteWidth = sizeof(cb_data);
1157     buffer_desc.Usage = D3D10_USAGE_DEFAULT;
1158     buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER;
1159     buffer_desc.CPUAccessFlags = 0;
1160     buffer_desc.MiscFlags = 0;
1161
1162     buffer_data.pSysMem = &cb_data;
1163     buffer_data.SysMemPitch = 0;
1164     buffer_data.SysMemSlicePitch = 0;
1165
1166     if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->device, &buffer_desc, &buffer_data, ps_cb)))
1167         ERR("Failed to create constant buffer, hr %#x.\n", hr);
1168
1169     return hr;
1170 }
1171
1172 static void d2d_brush_bind_gradient(struct d2d_brush *brush, ID3D10Device *device, unsigned int brush_idx)
1173 {
1174     ID3D10Device_PSSetShaderResources(device, 2 + brush_idx, 1, &brush->u.linear.gradient->view);
1175 }
1176
1177 static void d2d_brush_bind_bitmap(struct d2d_brush *brush, ID3D10Device *device, unsigned int brush_idx)
1178 {
1179     HRESULT hr;
1180
1181     ID3D10Device_PSSetShaderResources(device, brush_idx, 1, &brush->u.bitmap.bitmap->view);
1182     if (!brush->u.bitmap.sampler_state)
1183     {
1184         D3D10_SAMPLER_DESC sampler_desc;
1185
1186         if (brush->u.bitmap.interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR)
1187             sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_POINT;
1188         else
1189             sampler_desc.Filter = D3D10_FILTER_MIN_MAG_MIP_LINEAR;
1190         sampler_desc.AddressU = texture_address_mode_from_extend_mode(brush->u.bitmap.extend_mode_x);
1191         sampler_desc.AddressV = texture_address_mode_from_extend_mode(brush->u.bitmap.extend_mode_y);
1192         sampler_desc.AddressW = D3D10_TEXTURE_ADDRESS_CLAMP;
1193         sampler_desc.MipLODBias = 0.0f;
1194         sampler_desc.MaxAnisotropy = 0;
1195         sampler_desc.ComparisonFunc = D3D10_COMPARISON_NEVER;
1196         sampler_desc.BorderColor[0] = 0.0f;
1197         sampler_desc.BorderColor[1] = 0.0f;
1198         sampler_desc.BorderColor[2] = 0.0f;
1199         sampler_desc.BorderColor[3] = 0.0f;
1200         sampler_desc.MinLOD = 0.0f;
1201         sampler_desc.MaxLOD = 0.0f;
1202
1203         if (FAILED(hr = ID3D10Device_CreateSamplerState(device,
1204                         &sampler_desc, &brush->u.bitmap.sampler_state)))
1205             ERR("Failed to create sampler state, hr %#x.\n", hr);
1206     }
1207     ID3D10Device_PSSetSamplers(device, brush_idx, 1, &brush->u.bitmap.sampler_state);
1208 }
1209
1210 void d2d_brush_bind_resources(struct d2d_brush *brush, ID3D10Device *device, unsigned int brush_idx)
1211 {
1212     switch (brush->type)
1213     {
1214         case D2D_BRUSH_TYPE_SOLID:
1215             break;
1216
1217         case D2D_BRUSH_TYPE_LINEAR:
1218             d2d_brush_bind_gradient(brush, device, brush_idx);
1219             break;
1220
1221         case D2D_BRUSH_TYPE_BITMAP:
1222             d2d_brush_bind_bitmap(brush, device, brush_idx);
1223             break;
1224
1225         default:
1226             FIXME("Unhandled brush type %#x.\n", brush->type);
1227             break;
1228     }
1229 }