dlls/d2d1/device.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 "d2d1_private.h"
  20 #include <d3dcompiler.h>
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  23
  24 #define INITIAL_CLIP_STACK_SIZE 4
  25
  26 static const D2D1_MATRIX_3X2_F identity =
  27 {{{
  28     1.0f, 0.0f,
  29     0.0f, 1.0f,
  30     0.0f, 0.0f,
  31 }}};
  32
  33 struct d2d_draw_text_layout_ctx
  34 {
  35     ID2D1Brush *brush;
  36     D2D1_DRAW_TEXT_OPTIONS options;
  37 };
  38
  39 static inline struct d2d_device *impl_from_ID2D1Device(ID2D1Device1 *iface)
  40 {
  41     return CONTAINING_RECORD(iface, struct d2d_device, ID2D1Device1_iface);
  42 }
  43
  44 static ID2D1Brush *d2d_draw_get_text_brush(struct d2d_draw_text_layout_ctx *context, IUnknown *effect)
  45 {
  46     ID2D1Brush *brush = NULL;
  47
  48     if (effect && SUCCEEDED(IUnknown_QueryInterface(effect, &IID_ID2D1Brush, (void**)&brush)))
  49         return brush;
  50
  51     ID2D1Brush_AddRef(context->brush);
  52     return context->brush;
  53 }
  54
  55 static void d2d_rect_intersect(D2D1_RECT_F *dst, const D2D1_RECT_F *src)
  56 {
  57     if (src->left > dst->left)
  58         dst->left = src->left;
  59     if (src->top > dst->top)
  60         dst->top = src->top;
  61     if (src->right < dst->right)
  62         dst->right = src->right;
  63     if (src->bottom < dst->bottom)
  64         dst->bottom = src->bottom;
  65 }
  66
  67 static void d2d_rect_set(D2D1_RECT_F *dst, float left, float top, float right, float bottom)
  68 {
  69     dst->left = left;
  70     dst->top = top;
  71     dst->right = right;
  72     dst->bottom = bottom;
  73 }
  74
  75 static void d2d_size_set(D2D1_SIZE_U *dst, float width, float height)
  76 {
  77     dst->width = width;
  78     dst->height = height;
  79 }
  80
  81 static BOOL d2d_clip_stack_init(struct d2d_clip_stack *stack)
  82 {
  83     if (!(stack->stack = malloc(INITIAL_CLIP_STACK_SIZE * sizeof(*stack->stack))))
  84         return FALSE;
  85
  86     stack->size = INITIAL_CLIP_STACK_SIZE;
  87     stack->count = 0;
  88
  89     return TRUE;
  90 }
  91
  92 static void d2d_clip_stack_cleanup(struct d2d_clip_stack *stack)
  93 {
  94     free(stack->stack);
  95 }
  96
  97 static BOOL d2d_clip_stack_push(struct d2d_clip_stack *stack, const D2D1_RECT_F *rect)
  98 {
  99     D2D1_RECT_F r;
 100
 101     if (!d2d_array_reserve((void **)&stack->stack, &stack->size, stack->count + 1, sizeof(*stack->stack)))
 102         return FALSE;
 103
 104     r = *rect;
 105     if (stack->count)
 106         d2d_rect_intersect(&r, &stack->stack[stack->count - 1]);
 107     stack->stack[stack->count++] = r;
 108
 109     return TRUE;
 110 }
 111
 112 static void d2d_clip_stack_pop(struct d2d_clip_stack *stack)
 113 {
 114     if (!stack->count)
 115         return;
 116     --stack->count;
 117 }
 118
 119 static void d2d_device_context_draw(struct d2d_device_context *render_target, enum d2d_shape_type shape_type,
 120         ID3D11Buffer *ib, unsigned int index_count, ID3D11Buffer *vb, unsigned int vb_stride,
 121         struct d2d_brush *brush, struct d2d_brush *opacity_brush)
 122 {
 123     struct d2d_shape_resources *shape_resources = &render_target->shape_resources[shape_type];
 124     ID3DDeviceContextState *prev_state;
 125     ID3D11Device1 *device = render_target->d3d_device;
 126     ID3D11DeviceContext1 *context;
 127     ID3D11Buffer *vs_cb = render_target->vs_cb, *ps_cb = render_target->ps_cb;
 128     D3D11_RECT scissor_rect;
 129     unsigned int offset;
 130     D3D11_VIEWPORT vp;
 131
 132     vp.TopLeftX = 0;
 133     vp.TopLeftY = 0;
 134     vp.Width = render_target->pixel_size.width;
 135     vp.Height = render_target->pixel_size.height;
 136     vp.MinDepth = 0.0f;
 137     vp.MaxDepth = 1.0f;
 138
 139     if (render_target->cs)
 140         EnterCriticalSection(render_target->cs);
 141
 142     ID3D11Device1_GetImmediateContext1(device, &context);
 143     ID3D11DeviceContext1_SwapDeviceContextState(context, render_target->d3d_state, &prev_state);
 144
 145     ID3D11DeviceContext1_IASetInputLayout(context, shape_resources->il);
 146     ID3D11DeviceContext1_IASetPrimitiveTopology(context, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 147     ID3D11DeviceContext1_IASetIndexBuffer(context, ib, DXGI_FORMAT_R16_UINT, 0);
 148     offset = 0;
 149     ID3D11DeviceContext1_IASetVertexBuffers(context, 0, 1, &vb, &vb_stride, &offset);
 150     ID3D11DeviceContext1_VSSetConstantBuffers(context, 0, 1, &vs_cb);
 151     ID3D11DeviceContext1_VSSetShader(context, shape_resources->vs, NULL, 0);
 152     ID3D11DeviceContext1_PSSetConstantBuffers(context, 0, 1, &ps_cb);
 153     ID3D11DeviceContext1_PSSetShader(context, render_target->ps, NULL, 0);
 154     ID3D11DeviceContext1_RSSetViewports(context, 1, &vp);
 155     if (render_target->clip_stack.count)
 156     {
 157         const D2D1_RECT_F *clip_rect;
 158
 159         clip_rect = &render_target->clip_stack.stack[render_target->clip_stack.count - 1];
 160         scissor_rect.left = ceilf(clip_rect->left - 0.5f);
 161         scissor_rect.top = ceilf(clip_rect->top - 0.5f);
 162         scissor_rect.right = ceilf(clip_rect->right - 0.5f);
 163         scissor_rect.bottom = ceilf(clip_rect->bottom - 0.5f);
 164     }
 165     else
 166     {
 167         scissor_rect.left = 0.0f;
 168         scissor_rect.top = 0.0f;
 169         scissor_rect.right = render_target->pixel_size.width;
 170         scissor_rect.bottom = render_target->pixel_size.height;
 171     }
 172     ID3D11DeviceContext1_RSSetScissorRects(context, 1, &scissor_rect);
 173     ID3D11DeviceContext1_RSSetState(context, render_target->rs);
 174     ID3D11DeviceContext1_OMSetRenderTargets(context, 1, &render_target->target.bitmap->rtv, NULL);
 175     if (brush)
 176     {
 177         ID3D11DeviceContext1_OMSetBlendState(context, render_target->bs, NULL, D3D11_DEFAULT_SAMPLE_MASK);
 178         d2d_brush_bind_resources(brush, render_target, 0);
 179     }
 180     else
 181     {
 182         ID3D11DeviceContext1_OMSetBlendState(context, NULL, NULL, D3D11_DEFAULT_SAMPLE_MASK);
 183     }
 184     if (opacity_brush)
 185         d2d_brush_bind_resources(opacity_brush, render_target, 1);
 186
 187     if (ib)
 188         ID3D11DeviceContext1_DrawIndexed(context, index_count, 0, 0);
 189     else
 190         ID3D11DeviceContext1_Draw(context, index_count, 0);
 191
 192     ID3D11DeviceContext1_SwapDeviceContextState(context, prev_state, NULL);
 193     ID3D11DeviceContext1_Release(context);
 194     ID3DDeviceContextState_Release(prev_state);
 195
 196     if (render_target->cs)
 197         LeaveCriticalSection(render_target->cs);
 198 }
 199
 200 static void d2d_device_context_set_error(struct d2d_device_context *context, HRESULT code)
 201 {
 202     context->error.code = code;
 203     context->error.tag1 = context->drawing_state.tag1;
 204     context->error.tag2 = context->drawing_state.tag2;
 205 }
 206
 207 static inline struct d2d_device_context *impl_from_IUnknown(IUnknown *iface)
 208 {
 209     return CONTAINING_RECORD(iface, struct d2d_device_context, IUnknown_iface);
 210 }
 211
 212 static inline struct d2d_device_context *impl_from_ID2D1DeviceContext(ID2D1DeviceContext1 *iface)
 213 {
 214     return CONTAINING_RECORD(iface, struct d2d_device_context, ID2D1DeviceContext1_iface);
 215 }
 216
 217 static HRESULT STDMETHODCALLTYPE d2d_device_context_inner_QueryInterface(IUnknown *iface, REFIID iid, void **out)
 218 {
 219     struct d2d_device_context *context = impl_from_IUnknown(iface);
 220
 221     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 222
 223     if (IsEqualGUID(iid, &IID_ID2D1DeviceContext1)
 224             || IsEqualGUID(iid, &IID_ID2D1DeviceContext)
 225             || IsEqualGUID(iid, &IID_ID2D1RenderTarget)
 226             || IsEqualGUID(iid, &IID_ID2D1Resource)
 227             || IsEqualGUID(iid, &IID_IUnknown))
 228     {
 229         ID2D1DeviceContext1_AddRef(&context->ID2D1DeviceContext1_iface);
 230         *out = &context->ID2D1DeviceContext1_iface;
 231         return S_OK;
 232     }
 233     else if (IsEqualGUID(iid, &IID_ID2D1GdiInteropRenderTarget))
 234     {
 235         ID2D1GdiInteropRenderTarget_AddRef(&context->ID2D1GdiInteropRenderTarget_iface);
 236         *out = &context->ID2D1GdiInteropRenderTarget_iface;
 237         return S_OK;
 238     }
 239
 240     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 241
 242     *out = NULL;
 243     return E_NOINTERFACE;
 244 }
 245
 246 static ULONG STDMETHODCALLTYPE d2d_device_context_inner_AddRef(IUnknown *iface)
 247 {
 248     struct d2d_device_context *context = impl_from_IUnknown(iface);
 249     ULONG refcount = InterlockedIncrement(&context->refcount);
 250
 251     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
 252
 253     return refcount;
 254 }
 255
 256 static ULONG STDMETHODCALLTYPE d2d_device_context_inner_Release(IUnknown *iface)
 257 {
 258     struct d2d_device_context *context = impl_from_IUnknown(iface);
 259     ULONG refcount = InterlockedDecrement(&context->refcount);
 260
 261     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
 262
 263     if (!refcount)
 264     {
 265         unsigned int i, j, k;
 266
 267         d2d_clip_stack_cleanup(&context->clip_stack);
 268         IDWriteRenderingParams_Release(context->default_text_rendering_params);
 269         if (context->text_rendering_params)
 270             IDWriteRenderingParams_Release(context->text_rendering_params);
 271         if (context->bs)
 272             ID3D11BlendState_Release(context->bs);
 273         ID3D11RasterizerState_Release(context->rs);
 274         ID3D11Buffer_Release(context->vb);
 275         ID3D11Buffer_Release(context->ib);
 276         ID3D11Buffer_Release(context->ps_cb);
 277         ID3D11PixelShader_Release(context->ps);
 278         ID3D11Buffer_Release(context->vs_cb);
 279         for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i)
 280         {
 281             ID3D11VertexShader_Release(context->shape_resources[i].vs);
 282             ID3D11InputLayout_Release(context->shape_resources[i].il);
 283         }
 284         for (i = 0; i < D2D_SAMPLER_INTERPOLATION_MODE_COUNT; ++i)
 285         {
 286             for (j = 0; j < D2D_SAMPLER_EXTEND_MODE_COUNT; ++j)
 287             {
 288                 for (k = 0; k < D2D_SAMPLER_EXTEND_MODE_COUNT; ++k)
 289                 {
 290                     if (context->sampler_states[i][j][k])
 291                         ID3D11SamplerState_Release(context->sampler_states[i][j][k]);
 292                 }
 293             }
 294         }
 295         if (context->d3d_state)
 296             ID3DDeviceContextState_Release(context->d3d_state);
 297         if (context->target.object)
 298             IUnknown_Release(context->target.object);
 299         ID3D11Device1_Release(context->d3d_device);
 300         ID2D1Factory_Release(context->factory);
 301         ID2D1Device1_Release(&context->device->ID2D1Device1_iface);
 302         free(context);
 303     }
 304
 305     return refcount;
 306 }
 307
 308 static const struct IUnknownVtbl d2d_device_context_inner_unknown_vtbl =
 309 {
 310     d2d_device_context_inner_QueryInterface,
 311     d2d_device_context_inner_AddRef,
 312     d2d_device_context_inner_Release,
 313 };
 314
 315 static HRESULT STDMETHODCALLTYPE d2d_device_context_QueryInterface(ID2D1DeviceContext1 *iface, REFIID iid, void **out)
 316 {
 317     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 318
 319     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 320
 321     return IUnknown_QueryInterface(context->outer_unknown, iid, out);
 322 }
 323
 324 static ULONG STDMETHODCALLTYPE d2d_device_context_AddRef(ID2D1DeviceContext1 *iface)
 325 {
 326     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 327
 328     TRACE("iface %p.\n", iface);
 329
 330     return IUnknown_AddRef(context->outer_unknown);
 331 }
 332
 333 static ULONG STDMETHODCALLTYPE d2d_device_context_Release(ID2D1DeviceContext1 *iface)
 334 {
 335     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 336
 337     TRACE("iface %p.\n", iface);
 338
 339     return IUnknown_Release(context->outer_unknown);
 340 }
 341
 342 static void STDMETHODCALLTYPE d2d_device_context_GetFactory(ID2D1DeviceContext1 *iface, ID2D1Factory **factory)
 343 {
 344     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 345
 346     TRACE("iface %p, factory %p.\n", iface, factory);
 347
 348     *factory = render_target->factory;
 349     ID2D1Factory_AddRef(*factory);
 350 }
 351
 352 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmap(ID2D1DeviceContext1 *iface,
 353         D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 354 {
 355     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 356     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
 357     struct d2d_bitmap *object;
 358     HRESULT hr;
 359
 360     TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n",
 361             iface, size.width, size.height, src_data, pitch, desc, bitmap);
 362
 363     if (desc)
 364     {
 365         memcpy(&bitmap_desc, desc, sizeof(*desc));
 366         bitmap_desc.bitmapOptions = 0;
 367         bitmap_desc.colorContext = NULL;
 368     }
 369
 370     if (SUCCEEDED(hr = d2d_bitmap_create(context, size, src_data, pitch, desc ? &bitmap_desc : NULL, &object)))
 371         *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface;
 372
 373     return hr;
 374 }
 375
 376 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromWicBitmap(ID2D1DeviceContext1 *iface,
 377         IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 378 {
 379     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 380     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
 381     struct d2d_bitmap *object;
 382     HRESULT hr;
 383
 384     TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n",
 385             iface, bitmap_source, desc, bitmap);
 386
 387     if (desc)
 388     {
 389         memcpy(&bitmap_desc, desc, sizeof(*desc));
 390         bitmap_desc.bitmapOptions = 0;
 391         bitmap_desc.colorContext = NULL;
 392     }
 393
 394     if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context, bitmap_source, desc ? &bitmap_desc : NULL, &object)))
 395         *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface;
 396
 397     return hr;
 398 }
 399
 400 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSharedBitmap(ID2D1DeviceContext1 *iface,
 401         REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 402 {
 403     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 404     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
 405     struct d2d_bitmap *object;
 406     HRESULT hr;
 407
 408     TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n",
 409             iface, debugstr_guid(iid), data, desc, bitmap);
 410
 411     if (desc)
 412     {
 413         memcpy(&bitmap_desc, desc, sizeof(*desc));
 414         if (IsEqualIID(iid, &IID_IDXGISurface) || IsEqualIID(iid, &IID_IDXGISurface1))
 415             bitmap_desc.bitmapOptions = d2d_get_bitmap_options_for_surface(data);
 416         else
 417             bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW;
 418         bitmap_desc.colorContext = NULL;
 419     }
 420
 421     if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, iid, data, desc ? &bitmap_desc : NULL, &object)))
 422         *bitmap = (ID2D1Bitmap *)&object->ID2D1Bitmap1_iface;
 423
 424     return hr;
 425 }
 426
 427 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapBrush(ID2D1DeviceContext1 *iface,
 428         ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc,
 429         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush)
 430 {
 431     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 432     struct d2d_brush *object;
 433     HRESULT hr;
 434
 435     TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n",
 436             iface, bitmap, bitmap_brush_desc, brush_desc, brush);
 437
 438     if (SUCCEEDED(hr = d2d_bitmap_brush_create(context->factory, bitmap, (const D2D1_BITMAP_BRUSH_PROPERTIES1 *)bitmap_brush_desc,
 439             brush_desc, &object)))
 440         *brush = (ID2D1BitmapBrush *)&object->ID2D1Brush_iface;
 441
 442     return hr;
 443 }
 444
 445 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateSolidColorBrush(ID2D1DeviceContext1 *iface,
 446         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush)
 447 {
 448     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 449     struct d2d_brush *object;
 450     HRESULT hr;
 451
 452     TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush);
 453
 454     if (SUCCEEDED(hr = d2d_solid_color_brush_create(render_target->factory, color, desc, &object)))
 455         *brush = (ID2D1SolidColorBrush *)&object->ID2D1Brush_iface;
 456
 457     return hr;
 458 }
 459
 460 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateGradientStopCollection(ID2D1DeviceContext1 *iface,
 461         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode,
 462         ID2D1GradientStopCollection **gradient)
 463 {
 464     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 465     struct d2d_gradient *object;
 466     HRESULT hr;
 467
 468     TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n",
 469             iface, stops, stop_count, gamma, extend_mode, gradient);
 470
 471     if (SUCCEEDED(hr = d2d_gradient_create(render_target->factory, render_target->d3d_device,
 472             stops, stop_count, gamma, extend_mode, &object)))
 473         *gradient = &object->ID2D1GradientStopCollection_iface;
 474
 475     return hr;
 476 }
 477
 478 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateLinearGradientBrush(ID2D1DeviceContext1 *iface,
 479         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 480         ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush)
 481 {
 482     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 483     struct d2d_brush *object;
 484     HRESULT hr;
 485
 486     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 487             iface, gradient_brush_desc, brush_desc, gradient, brush);
 488
 489     if (SUCCEEDED(hr = d2d_linear_gradient_brush_create(render_target->factory, gradient_brush_desc, brush_desc,
 490         gradient, &object)))
 491         *brush = (ID2D1LinearGradientBrush *)&object->ID2D1Brush_iface;
 492
 493     return hr;
 494 }
 495
 496 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateRadialGradientBrush(ID2D1DeviceContext1 *iface,
 497         const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 498         ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush)
 499 {
 500     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 501     struct d2d_brush *object;
 502     HRESULT hr;
 503
 504     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 505             iface, gradient_brush_desc, brush_desc, gradient, brush);
 506
 507     if (SUCCEEDED(hr = d2d_radial_gradient_brush_create(render_target->factory,
 508             gradient_brush_desc, brush_desc, gradient, &object)))
 509         *brush = (ID2D1RadialGradientBrush *)&object->ID2D1Brush_iface;
 510
 511     return hr;
 512 }
 513
 514 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateCompatibleRenderTarget(ID2D1DeviceContext1 *iface,
 515         const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format,
 516         D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **rt)
 517 {
 518     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 519     struct d2d_bitmap_render_target *object;
 520     HRESULT hr;
 521
 522     TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p.\n",
 523             iface, size, pixel_size, format, options, rt);
 524
 525     if (!(object = calloc(1, sizeof(*object))))
 526         return E_OUTOFMEMORY;
 527
 528     if (FAILED(hr = d2d_bitmap_render_target_init(object, render_target, size, pixel_size,
 529             format, options)))
 530     {
 531         WARN("Failed to initialise render target, hr %#lx.\n", hr);
 532         free(object);
 533         return hr;
 534     }
 535
 536     TRACE("Created render target %p.\n", object);
 537     *rt = &object->ID2D1BitmapRenderTarget_iface;
 538
 539     return S_OK;
 540 }
 541
 542 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateLayer(ID2D1DeviceContext1 *iface,
 543         const D2D1_SIZE_F *size, ID2D1Layer **layer)
 544 {
 545     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 546     struct d2d_layer *object;
 547     HRESULT hr;
 548
 549     TRACE("iface %p, size %p, layer %p.\n", iface, size, layer);
 550
 551     if (SUCCEEDED(hr = d2d_layer_create(render_target->factory, size, &object)))
 552         *layer = &object->ID2D1Layer_iface;
 553
 554     return hr;
 555 }
 556
 557 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateMesh(ID2D1DeviceContext1 *iface, ID2D1Mesh **mesh)
 558 {
 559     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 560     struct d2d_mesh *object;
 561     HRESULT hr;
 562
 563     TRACE("iface %p, mesh %p.\n", iface, mesh);
 564
 565     if (SUCCEEDED(hr = d2d_mesh_create(render_target->factory, &object)))
 566         *mesh = &object->ID2D1Mesh_iface;
 567
 568     return hr;
 569 }
 570
 571 static void STDMETHODCALLTYPE d2d_device_context_DrawLine(ID2D1DeviceContext1 *iface,
 572         D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 573 {
 574     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 575     ID2D1PathGeometry *geometry;
 576     ID2D1GeometrySink *sink;
 577     HRESULT hr;
 578
 579     TRACE("iface %p, p0 %s, p1 %s, brush %p, stroke_width %.8e, stroke_style %p.\n",
 580             iface, debug_d2d_point_2f(&p0), debug_d2d_point_2f(&p1), brush, stroke_width, stroke_style);
 581
 582     if (context->target.type == D2D_TARGET_COMMAND_LIST)
 583     {
 584         d2d_command_list_draw_line(context->target.command_list, context, p0, p1, brush, stroke_width, stroke_style);
 585         return;
 586     }
 587
 588     if (FAILED(hr = ID2D1Factory_CreatePathGeometry(context->factory, &geometry)))
 589     {
 590         WARN("Failed to create path geometry, hr %#lx.\n", hr);
 591         return;
 592     }
 593
 594     if (FAILED(hr = ID2D1PathGeometry_Open(geometry, &sink)))
 595     {
 596         WARN("Failed to open geometry sink, hr %#lx.\n", hr);
 597         ID2D1PathGeometry_Release(geometry);
 598         return;
 599     }
 600
 601     ID2D1GeometrySink_BeginFigure(sink, p0, D2D1_FIGURE_BEGIN_HOLLOW);
 602     ID2D1GeometrySink_AddLine(sink, p1);
 603     ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_OPEN);
 604     if (FAILED(hr = ID2D1GeometrySink_Close(sink)))
 605         WARN("Failed to close geometry sink, hr %#lx.\n", hr);
 606     ID2D1GeometrySink_Release(sink);
 607
 608     ID2D1DeviceContext1_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style);
 609     ID2D1PathGeometry_Release(geometry);
 610 }
 611
 612 static void STDMETHODCALLTYPE d2d_device_context_DrawRectangle(ID2D1DeviceContext1 *iface,
 613         const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 614 {
 615     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 616     ID2D1RectangleGeometry *geometry;
 617     HRESULT hr;
 618
 619     TRACE("iface %p, rect %s, brush %p, stroke_width %.8e, stroke_style %p.\n",
 620             iface, debug_d2d_rect_f(rect), brush, stroke_width, stroke_style);
 621
 622     if (context->target.type == D2D_TARGET_COMMAND_LIST)
 623     {
 624         d2d_command_list_draw_rectangle(context->target.command_list, context, rect, brush, stroke_width, stroke_style);
 625         return;
 626     }
 627
 628     if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(context->factory, rect, &geometry)))
 629     {
 630         ERR("Failed to create geometry, hr %#lx.\n", hr);
 631         return;
 632     }
 633
 634     ID2D1DeviceContext1_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style);
 635     ID2D1RectangleGeometry_Release(geometry);
 636 }
 637
 638 static void STDMETHODCALLTYPE d2d_device_context_FillRectangle(ID2D1DeviceContext1 *iface,
 639         const D2D1_RECT_F *rect, ID2D1Brush *brush)
 640 {
 641     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 642     ID2D1RectangleGeometry *geometry;
 643     HRESULT hr;
 644
 645     TRACE("iface %p, rect %s, brush %p.\n", iface, debug_d2d_rect_f(rect), brush);
 646
 647     if (context->target.type == D2D_TARGET_COMMAND_LIST)
 648     {
 649         d2d_command_list_fill_rectangle(context->target.command_list, context, rect, brush);
 650         return;
 651     }
 652
 653     if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(context->factory, rect, &geometry)))
 654     {
 655         ERR("Failed to create geometry, hr %#lx.\n", hr);
 656         return;
 657     }
 658
 659     ID2D1DeviceContext1_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL);
 660     ID2D1RectangleGeometry_Release(geometry);
 661 }
 662
 663 static void STDMETHODCALLTYPE d2d_device_context_DrawRoundedRectangle(ID2D1DeviceContext1 *iface,
 664         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 665 {
 666     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 667     ID2D1RoundedRectangleGeometry *geometry;
 668     HRESULT hr;
 669
 670     TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 671             iface, rect, brush, stroke_width, stroke_style);
 672
 673     if (FAILED(hr = ID2D1Factory_CreateRoundedRectangleGeometry(render_target->factory, rect, &geometry)))
 674     {
 675         ERR("Failed to create geometry, hr %#lx.\n", hr);
 676         return;
 677     }
 678
 679     ID2D1DeviceContext1_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style);
 680     ID2D1RoundedRectangleGeometry_Release(geometry);
 681 }
 682
 683 static void STDMETHODCALLTYPE d2d_device_context_FillRoundedRectangle(ID2D1DeviceContext1 *iface,
 684         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush)
 685 {
 686     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 687     ID2D1RoundedRectangleGeometry *geometry;
 688     HRESULT hr;
 689
 690     TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush);
 691
 692     if (FAILED(hr = ID2D1Factory_CreateRoundedRectangleGeometry(render_target->factory, rect, &geometry)))
 693     {
 694         ERR("Failed to create geometry, hr %#lx.\n", hr);
 695         return;
 696     }
 697
 698     ID2D1DeviceContext1_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL);
 699     ID2D1RoundedRectangleGeometry_Release(geometry);
 700 }
 701
 702 static void STDMETHODCALLTYPE d2d_device_context_DrawEllipse(ID2D1DeviceContext1 *iface,
 703         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 704 {
 705     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 706     ID2D1EllipseGeometry *geometry;
 707     HRESULT hr;
 708
 709     TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 710             iface, ellipse, brush, stroke_width, stroke_style);
 711
 712     if (FAILED(hr = ID2D1Factory_CreateEllipseGeometry(render_target->factory, ellipse, &geometry)))
 713     {
 714         ERR("Failed to create geometry, hr %#lx.\n", hr);
 715         return;
 716     }
 717
 718     ID2D1DeviceContext1_DrawGeometry(iface, (ID2D1Geometry *)geometry, brush, stroke_width, stroke_style);
 719     ID2D1EllipseGeometry_Release(geometry);
 720 }
 721
 722 static void STDMETHODCALLTYPE d2d_device_context_FillEllipse(ID2D1DeviceContext1 *iface,
 723         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush)
 724 {
 725     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
 726     ID2D1EllipseGeometry *geometry;
 727     HRESULT hr;
 728
 729     TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush);
 730
 731     if (FAILED(hr = ID2D1Factory_CreateEllipseGeometry(render_target->factory, ellipse, &geometry)))
 732     {
 733         ERR("Failed to create geometry, hr %#lx.\n", hr);
 734         return;
 735     }
 736
 737     ID2D1DeviceContext1_FillGeometry(iface, (ID2D1Geometry *)geometry, brush, NULL);
 738     ID2D1EllipseGeometry_Release(geometry);
 739 }
 740
 741 static HRESULT d2d_device_context_update_ps_cb(struct d2d_device_context *context,
 742         struct d2d_brush *brush, struct d2d_brush *opacity_brush, BOOL outline, BOOL is_arc)
 743 {
 744     D3D11_MAPPED_SUBRESOURCE map_desc;
 745     ID3D11DeviceContext *d3d_context;
 746     struct d2d_ps_cb *cb_data;
 747     HRESULT hr;
 748
 749     ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context);
 750
 751     if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->ps_cb,
 752             0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc)))
 753     {
 754         WARN("Failed to map constant buffer, hr %#lx.\n", hr);
 755         ID3D11DeviceContext_Release(d3d_context);
 756         return hr;
 757     }
 758
 759     cb_data = map_desc.pData;
 760     cb_data->outline = outline;
 761     cb_data->is_arc = is_arc;
 762     cb_data->pad[0] = 0;
 763     cb_data->pad[1] = 0;
 764     if (!d2d_brush_fill_cb(brush, &cb_data->colour_brush))
 765         WARN("Failed to initialize colour brush buffer.\n");
 766     if (!d2d_brush_fill_cb(opacity_brush, &cb_data->opacity_brush))
 767         WARN("Failed to initialize opacity brush buffer.\n");
 768
 769     ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->ps_cb, 0);
 770     ID3D11DeviceContext_Release(d3d_context);
 771
 772     return hr;
 773 }
 774
 775 static HRESULT d2d_device_context_update_vs_cb(struct d2d_device_context *context,
 776         const D2D_MATRIX_3X2_F *geometry_transform, float stroke_width)
 777 {
 778     D3D11_MAPPED_SUBRESOURCE map_desc;
 779     ID3D11DeviceContext *d3d_context;
 780     const D2D1_MATRIX_3X2_F *w;
 781     struct d2d_vs_cb *cb_data;
 782     float tmp_x, tmp_y;
 783     HRESULT hr;
 784
 785     ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context);
 786
 787     if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->vs_cb,
 788             0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc)))
 789     {
 790         WARN("Failed to map constant buffer, hr %#lx.\n", hr);
 791         ID3D11DeviceContext_Release(d3d_context);
 792         return hr;
 793     }
 794
 795     cb_data = map_desc.pData;
 796     cb_data->transform_geometry._11 = geometry_transform->_11;
 797     cb_data->transform_geometry._21 = geometry_transform->_21;
 798     cb_data->transform_geometry._31 = geometry_transform->_31;
 799     cb_data->transform_geometry.pad0 = 0.0f;
 800     cb_data->transform_geometry._12 = geometry_transform->_12;
 801     cb_data->transform_geometry._22 = geometry_transform->_22;
 802     cb_data->transform_geometry._32 = geometry_transform->_32;
 803     cb_data->transform_geometry.stroke_width = stroke_width;
 804
 805     w = &context->drawing_state.transform;
 806
 807     tmp_x = context->desc.dpiX / 96.0f;
 808     cb_data->transform_rtx.x = w->_11 * tmp_x;
 809     cb_data->transform_rtx.y = w->_21 * tmp_x;
 810     cb_data->transform_rtx.z = w->_31 * tmp_x;
 811     cb_data->transform_rtx.w = 2.0f / context->pixel_size.width;
 812
 813     tmp_y = context->desc.dpiY / 96.0f;
 814     cb_data->transform_rty.x = w->_12 * tmp_y;
 815     cb_data->transform_rty.y = w->_22 * tmp_y;
 816     cb_data->transform_rty.z = w->_32 * tmp_y;
 817     cb_data->transform_rty.w = -2.0f / context->pixel_size.height;
 818
 819     ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->vs_cb, 0);
 820     ID3D11DeviceContext_Release(d3d_context);
 821
 822     return S_OK;
 823 }
 824
 825 static void d2d_device_context_draw_geometry(struct d2d_device_context *render_target,
 826         const struct d2d_geometry *geometry, struct d2d_brush *brush, float stroke_width)
 827 {
 828     D3D11_SUBRESOURCE_DATA buffer_data;
 829     D3D11_BUFFER_DESC buffer_desc;
 830     ID3D11Buffer *ib, *vb;
 831     HRESULT hr;
 832
 833     if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, stroke_width)))
 834     {
 835         WARN("Failed to update vs constant buffer, hr %#lx.\n", hr);
 836         return;
 837     }
 838
 839     if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, FALSE)))
 840     {
 841         WARN("Failed to update ps constant buffer, hr %#lx.\n", hr);
 842         return;
 843     }
 844
 845     buffer_desc.Usage = D3D11_USAGE_DEFAULT;
 846     buffer_desc.CPUAccessFlags = 0;
 847     buffer_desc.MiscFlags = 0;
 848
 849     buffer_data.SysMemPitch = 0;
 850     buffer_data.SysMemSlicePitch = 0;
 851
 852     if (geometry->outline.face_count)
 853     {
 854         buffer_desc.ByteWidth = geometry->outline.face_count * sizeof(*geometry->outline.faces);
 855         buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
 856         buffer_data.pSysMem = geometry->outline.faces;
 857
 858         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib)))
 859         {
 860             WARN("Failed to create index buffer, hr %#lx.\n", hr);
 861             return;
 862         }
 863
 864         buffer_desc.ByteWidth = geometry->outline.vertex_count * sizeof(*geometry->outline.vertices);
 865         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 866         buffer_data.pSysMem = geometry->outline.vertices;
 867
 868         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
 869         {
 870             ERR("Failed to create vertex buffer, hr %#lx.\n", hr);
 871             ID3D11Buffer_Release(ib);
 872             return;
 873         }
 874
 875         d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_OUTLINE, ib, 3 * geometry->outline.face_count, vb,
 876                 sizeof(*geometry->outline.vertices), brush, NULL);
 877
 878         ID3D11Buffer_Release(vb);
 879         ID3D11Buffer_Release(ib);
 880     }
 881
 882     if (geometry->outline.bezier_face_count)
 883     {
 884         buffer_desc.ByteWidth = geometry->outline.bezier_face_count * sizeof(*geometry->outline.bezier_faces);
 885         buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
 886         buffer_data.pSysMem = geometry->outline.bezier_faces;
 887
 888         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib)))
 889         {
 890             WARN("Failed to create curves index buffer, hr %#lx.\n", hr);
 891             return;
 892         }
 893
 894         buffer_desc.ByteWidth = geometry->outline.bezier_count * sizeof(*geometry->outline.beziers);
 895         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 896         buffer_data.pSysMem = geometry->outline.beziers;
 897
 898         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
 899         {
 900             ERR("Failed to create curves vertex buffer, hr %#lx.\n", hr);
 901             ID3D11Buffer_Release(ib);
 902             return;
 903         }
 904
 905         d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_BEZIER_OUTLINE, ib,
 906                 3 * geometry->outline.bezier_face_count, vb,
 907                 sizeof(*geometry->outline.beziers), brush, NULL);
 908
 909         ID3D11Buffer_Release(vb);
 910         ID3D11Buffer_Release(ib);
 911     }
 912
 913     if (geometry->outline.arc_face_count)
 914     {
 915         buffer_desc.ByteWidth = geometry->outline.arc_face_count * sizeof(*geometry->outline.arc_faces);
 916         buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
 917         buffer_data.pSysMem = geometry->outline.arc_faces;
 918
 919         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib)))
 920         {
 921             WARN("Failed to create arcs index buffer, hr %#lx.\n", hr);
 922             return;
 923         }
 924
 925         buffer_desc.ByteWidth = geometry->outline.arc_count * sizeof(*geometry->outline.arcs);
 926         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
 927         buffer_data.pSysMem = geometry->outline.arcs;
 928
 929         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
 930         {
 931             ERR("Failed to create arcs vertex buffer, hr %#lx.\n", hr);
 932             ID3D11Buffer_Release(ib);
 933             return;
 934         }
 935
 936         if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, TRUE)))
 937             d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_ARC_OUTLINE, ib,
 938                     3 * geometry->outline.arc_face_count, vb,
 939                     sizeof(*geometry->outline.arcs), brush, NULL);
 940
 941         ID3D11Buffer_Release(vb);
 942         ID3D11Buffer_Release(ib);
 943     }
 944 }
 945
 946 static void STDMETHODCALLTYPE d2d_device_context_DrawGeometry(ID2D1DeviceContext1 *iface,
 947         ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 948 {
 949     const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry);
 950     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
 951     struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush);
 952     struct d2d_stroke_style *stroke_style_impl = unsafe_impl_from_ID2D1StrokeStyle(stroke_style);
 953
 954     TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 955             iface, geometry, brush, stroke_width, stroke_style);
 956
 957     if (context->target.type == D2D_TARGET_COMMAND_LIST)
 958     {
 959         d2d_command_list_draw_geometry(context->target.command_list, context, geometry, brush,
 960                 stroke_width, stroke_style);
 961         return;
 962     }
 963
 964     if (stroke_style)
 965         FIXME("Ignoring stroke style %p.\n", stroke_style);
 966
 967     if (stroke_style_impl)
 968     {
 969         if (stroke_style_impl->desc.transformType == D2D1_STROKE_TRANSFORM_TYPE_FIXED)
 970             stroke_width /= context->drawing_state.transform.m11;
 971     }
 972
 973     d2d_device_context_draw_geometry(context, geometry_impl, brush_impl, stroke_width);
 974 }
 975
 976 static void d2d_device_context_fill_geometry(struct d2d_device_context *render_target,
 977         const struct d2d_geometry *geometry, struct d2d_brush *brush, struct d2d_brush *opacity_brush)
 978 {
 979     D3D11_SUBRESOURCE_DATA buffer_data;
 980     D3D11_BUFFER_DESC buffer_desc;
 981     ID3D11Buffer *ib, *vb;
 982     HRESULT hr;
 983
 984     buffer_desc.Usage = D3D11_USAGE_DEFAULT;
 985     buffer_desc.CPUAccessFlags = 0;
 986     buffer_desc.MiscFlags = 0;
 987
 988     buffer_data.SysMemPitch = 0;
 989     buffer_data.SysMemSlicePitch = 0;
 990
 991     if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, 0.0f)))
 992     {
 993         WARN("Failed to update vs constant buffer, hr %#lx.\n", hr);
 994         return;
 995     }
 996
 997     if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, FALSE)))
 998     {
 999         WARN("Failed to update ps constant buffer, hr %#lx.\n", hr);
1000         return;
1001     }
1002
1003     if (geometry->fill.face_count)
1004     {
1005         buffer_desc.ByteWidth = geometry->fill.face_count * sizeof(*geometry->fill.faces);
1006         buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
1007         buffer_data.pSysMem = geometry->fill.faces;
1008
1009         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib)))
1010         {
1011             WARN("Failed to create index buffer, hr %#lx.\n", hr);
1012             return;
1013         }
1014
1015         buffer_desc.ByteWidth = geometry->fill.vertex_count * sizeof(*geometry->fill.vertices);
1016         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
1017         buffer_data.pSysMem = geometry->fill.vertices;
1018
1019         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
1020         {
1021             ERR("Failed to create vertex buffer, hr %#lx.\n", hr);
1022             ID3D11Buffer_Release(ib);
1023             return;
1024         }
1025
1026         d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_TRIANGLE, ib, 3 * geometry->fill.face_count, vb,
1027                 sizeof(*geometry->fill.vertices), brush, opacity_brush);
1028
1029         ID3D11Buffer_Release(vb);
1030         ID3D11Buffer_Release(ib);
1031     }
1032
1033     if (geometry->fill.bezier_vertex_count)
1034     {
1035         buffer_desc.ByteWidth = geometry->fill.bezier_vertex_count * sizeof(*geometry->fill.bezier_vertices);
1036         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
1037         buffer_data.pSysMem = geometry->fill.bezier_vertices;
1038
1039         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
1040         {
1041             ERR("Failed to create curves vertex buffer, hr %#lx.\n", hr);
1042             return;
1043         }
1044
1045         d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.bezier_vertex_count, vb,
1046                 sizeof(*geometry->fill.bezier_vertices), brush, opacity_brush);
1047
1048         ID3D11Buffer_Release(vb);
1049     }
1050
1051     if (geometry->fill.arc_vertex_count)
1052     {
1053         buffer_desc.ByteWidth = geometry->fill.arc_vertex_count * sizeof(*geometry->fill.arc_vertices);
1054         buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
1055         buffer_data.pSysMem = geometry->fill.arc_vertices;
1056
1057         if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb)))
1058         {
1059             ERR("Failed to create arc vertex buffer, hr %#lx.\n", hr);
1060             return;
1061         }
1062
1063         if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, TRUE)))
1064             d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.arc_vertex_count, vb,
1065                     sizeof(*geometry->fill.arc_vertices), brush, opacity_brush);
1066
1067         ID3D11Buffer_Release(vb);
1068     }
1069 }
1070
1071 static void STDMETHODCALLTYPE d2d_device_context_FillGeometry(ID2D1DeviceContext1 *iface,
1072         ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush)
1073 {
1074     const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry);
1075     struct d2d_brush *opacity_brush_impl = unsafe_impl_from_ID2D1Brush(opacity_brush);
1076     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1077     struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush);
1078
1079     TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush);
1080
1081     if (FAILED(context->error.code))
1082         return;
1083
1084     if (opacity_brush && brush_impl->type != D2D_BRUSH_TYPE_BITMAP)
1085     {
1086         d2d_device_context_set_error(context, D2DERR_INCOMPATIBLE_BRUSH_TYPES);
1087         return;
1088     }
1089
1090     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1091         d2d_command_list_fill_geometry(context->target.command_list, context, geometry, brush, opacity_brush);
1092     else
1093         d2d_device_context_fill_geometry(context, geometry_impl, brush_impl, opacity_brush_impl);
1094 }
1095
1096 static void STDMETHODCALLTYPE d2d_device_context_FillMesh(ID2D1DeviceContext1 *iface,
1097         ID2D1Mesh *mesh, ID2D1Brush *brush)
1098 {
1099     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1100
1101     FIXME("iface %p, mesh %p, brush %p stub!\n", iface, mesh, brush);
1102
1103     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1104         d2d_command_list_fill_mesh(context->target.command_list, context, mesh, brush);
1105 }
1106
1107 static void STDMETHODCALLTYPE d2d_device_context_FillOpacityMask(ID2D1DeviceContext1 *iface,
1108         ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content,
1109         const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect)
1110 {
1111     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1112
1113     FIXME("iface %p, mask %p, brush %p, content %#x, dst_rect %s, src_rect %s stub!\n",
1114             iface, mask, brush, content, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect));
1115
1116     if (FAILED(context->error.code))
1117         return;
1118
1119     if (context->drawing_state.antialiasMode != D2D1_ANTIALIAS_MODE_ALIASED)
1120     {
1121         d2d_device_context_set_error(context, D2DERR_WRONG_STATE);
1122         return;
1123     }
1124
1125     if ((unsigned int)content > D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE)
1126     {
1127         d2d_device_context_set_error(context, E_INVALIDARG);
1128         return;
1129     }
1130
1131     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1132         d2d_command_list_fill_opacity_mask(context->target.command_list, context, mask, brush, dst_rect, src_rect);
1133 }
1134
1135 static void d2d_device_context_draw_bitmap(struct d2d_device_context *context, ID2D1Bitmap *bitmap,
1136         const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode,
1137         const D2D1_RECT_F *src_rect, const D2D1_POINT_2F *offset,
1138         const D2D1_MATRIX_4X4_F *perspective_transform)
1139 {
1140     D2D1_BITMAP_BRUSH_PROPERTIES1 bitmap_brush_desc;
1141     D2D1_BRUSH_PROPERTIES brush_desc;
1142     struct d2d_brush *brush;
1143     D2D1_SIZE_F size;
1144     D2D1_RECT_F s, d;
1145     HRESULT hr;
1146
1147     if (perspective_transform)
1148         FIXME("Perspective transform is ignored.\n");
1149
1150     size = ID2D1Bitmap_GetSize(bitmap);
1151     d2d_rect_set(&s, 0.0f, 0.0f, size.width, size.height);
1152     if (src_rect && src_rect->left <= src_rect->right
1153             && src_rect->top <= src_rect->bottom)
1154     {
1155         d2d_rect_intersect(&s, src_rect);
1156     }
1157
1158     if (s.left == s.right || s.top == s.bottom)
1159         return;
1160
1161     if (dst_rect)
1162     {
1163         d = *dst_rect;
1164     }
1165     else
1166     {
1167         d.left = 0.0f;
1168         d.top = 0.0f;
1169         d.right = s.right - s.left;
1170         d.bottom = s.bottom - s.top;
1171     }
1172
1173     if (offset)
1174     {
1175         d.left += offset->x;
1176         d.top += offset->y;
1177         d.right += offset->x;
1178         d.bottom += offset->y;
1179     }
1180
1181     bitmap_brush_desc.extendModeX = D2D1_EXTEND_MODE_CLAMP;
1182     bitmap_brush_desc.extendModeY = D2D1_EXTEND_MODE_CLAMP;
1183     bitmap_brush_desc.interpolationMode = interpolation_mode;
1184
1185     brush_desc.opacity = opacity;
1186     brush_desc.transform._11 = fabsf((d.right - d.left) / (s.right - s.left));
1187     brush_desc.transform._21 = 0.0f;
1188     brush_desc.transform._31 = min(d.left, d.right) - min(s.left, s.right) * brush_desc.transform._11;
1189     brush_desc.transform._12 = 0.0f;
1190     brush_desc.transform._22 = fabsf((d.bottom - d.top) / (s.bottom - s.top));
1191     brush_desc.transform._32 = min(d.top, d.bottom) - min(s.top, s.bottom) * brush_desc.transform._22;
1192
1193     if (FAILED(hr = d2d_bitmap_brush_create(context->factory, bitmap, &bitmap_brush_desc, &brush_desc, &brush)))
1194     {
1195         ERR("Failed to create bitmap brush, hr %#lx.\n", hr);
1196         return;
1197     }
1198
1199     d2d_device_context_FillRectangle(&context->ID2D1DeviceContext1_iface, &d, &brush->ID2D1Brush_iface);
1200     ID2D1Brush_Release(&brush->ID2D1Brush_iface);
1201 }
1202
1203 static void STDMETHODCALLTYPE d2d_device_context_DrawBitmap(ID2D1DeviceContext1 *iface,
1204         ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity,
1205         D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect)
1206 {
1207     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1208
1209     TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, src_rect %s.\n",
1210             iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode, debug_d2d_rect_f(src_rect));
1211
1212     if (interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR
1213             && interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_LINEAR)
1214     {
1215         d2d_device_context_set_error(context, E_INVALIDARG);
1216         return;
1217     }
1218
1219     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1220     {
1221         d2d_command_list_draw_bitmap(context->target.command_list, bitmap, dst_rect, opacity,
1222                 d2d1_1_interp_mode_from_d2d1(interpolation_mode), src_rect, NULL);
1223     }
1224     else
1225     {
1226         d2d_device_context_draw_bitmap(context, bitmap, dst_rect, opacity,
1227                 d2d1_1_interp_mode_from_d2d1(interpolation_mode), src_rect, NULL, NULL);
1228     }
1229 }
1230
1231 static void STDMETHODCALLTYPE d2d_device_context_DrawText(ID2D1DeviceContext1 *iface,
1232         const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect,
1233         ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode)
1234 {
1235     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1236     IDWriteTextLayout *text_layout;
1237     IDWriteFactory *dwrite_factory;
1238     D2D1_POINT_2F origin;
1239     float width, height;
1240     HRESULT hr;
1241
1242     TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %s, "
1243             "brush %p, options %#x, measuring_mode %#x.\n",
1244             iface, debugstr_wn(string, string_len), string_len, text_format, debug_d2d_rect_f(layout_rect),
1245             brush, options, measuring_mode);
1246
1247     if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
1248             &IID_IDWriteFactory, (IUnknown **)&dwrite_factory)))
1249     {
1250         ERR("Failed to create dwrite factory, hr %#lx.\n", hr);
1251         return;
1252     }
1253
1254     width = max(0.0f, layout_rect->right - layout_rect->left);
1255     height = max(0.0f, layout_rect->bottom - layout_rect->top);
1256     if (measuring_mode == DWRITE_MEASURING_MODE_NATURAL)
1257         hr = IDWriteFactory_CreateTextLayout(dwrite_factory, string, string_len, text_format,
1258                 width, height, &text_layout);
1259     else
1260         hr = IDWriteFactory_CreateGdiCompatibleTextLayout(dwrite_factory, string, string_len, text_format,
1261                 width, height, render_target->desc.dpiX / 96.0f, (DWRITE_MATRIX *)&render_target->drawing_state.transform,
1262                 measuring_mode == DWRITE_MEASURING_MODE_GDI_NATURAL, &text_layout);
1263     IDWriteFactory_Release(dwrite_factory);
1264     if (FAILED(hr))
1265     {
1266         ERR("Failed to create text layout, hr %#lx.\n", hr);
1267         return;
1268     }
1269
1270     d2d_point_set(&origin, min(layout_rect->left, layout_rect->right), min(layout_rect->top, layout_rect->bottom));
1271     ID2D1DeviceContext1_DrawTextLayout(iface, origin, text_layout, brush, options);
1272     IDWriteTextLayout_Release(text_layout);
1273 }
1274
1275 static void STDMETHODCALLTYPE d2d_device_context_DrawTextLayout(ID2D1DeviceContext1 *iface,
1276         D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options)
1277 {
1278     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1279     struct d2d_draw_text_layout_ctx ctx;
1280     HRESULT hr;
1281
1282     TRACE("iface %p, origin %s, layout %p, brush %p, options %#x.\n",
1283             iface, debug_d2d_point_2f(&origin), layout, brush, options);
1284
1285     ctx.brush = brush;
1286     ctx.options = options;
1287
1288     if (FAILED(hr = IDWriteTextLayout_Draw(layout,
1289             &ctx, &render_target->IDWriteTextRenderer_iface, origin.x, origin.y)))
1290         FIXME("Failed to draw text layout, hr %#lx.\n", hr);
1291 }
1292
1293 static D2D1_ANTIALIAS_MODE d2d_device_context_set_aa_mode_from_text_aa_mode(struct d2d_device_context *rt)
1294 {
1295     D2D1_ANTIALIAS_MODE prev_antialias_mode = rt->drawing_state.antialiasMode;
1296     rt->drawing_state.antialiasMode = rt->drawing_state.textAntialiasMode == D2D1_TEXT_ANTIALIAS_MODE_ALIASED ?
1297             D2D1_ANTIALIAS_MODE_ALIASED : D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
1298     return prev_antialias_mode;
1299 }
1300
1301 static void d2d_device_context_draw_glyph_run_outline(struct d2d_device_context *render_target,
1302         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush)
1303 {
1304     D2D1_MATRIX_3X2_F *transform, prev_transform;
1305     D2D1_ANTIALIAS_MODE prev_antialias_mode;
1306     ID2D1PathGeometry *geometry;
1307     ID2D1GeometrySink *sink;
1308     HRESULT hr;
1309
1310     if (FAILED(hr = ID2D1Factory_CreatePathGeometry(render_target->factory, &geometry)))
1311     {
1312         ERR("Failed to create geometry, hr %#lx.\n", hr);
1313         return;
1314     }
1315
1316     if (FAILED(hr = ID2D1PathGeometry_Open(geometry, &sink)))
1317     {
1318         ERR("Failed to open geometry sink, hr %#lx.\n", hr);
1319         ID2D1PathGeometry_Release(geometry);
1320         return;
1321     }
1322
1323     if (FAILED(hr = IDWriteFontFace_GetGlyphRunOutline(glyph_run->fontFace, glyph_run->fontEmSize,
1324             glyph_run->glyphIndices, glyph_run->glyphAdvances, glyph_run->glyphOffsets, glyph_run->glyphCount,
1325             glyph_run->isSideways, glyph_run->bidiLevel & 1, (IDWriteGeometrySink *)sink)))
1326     {
1327         ERR("Failed to get glyph run outline, hr %#lx.\n", hr);
1328         ID2D1GeometrySink_Release(sink);
1329         ID2D1PathGeometry_Release(geometry);
1330         return;
1331     }
1332
1333     if (FAILED(hr = ID2D1GeometrySink_Close(sink)))
1334         ERR("Failed to close geometry sink, hr %#lx.\n", hr);
1335     ID2D1GeometrySink_Release(sink);
1336
1337     transform = &render_target->drawing_state.transform;
1338     prev_transform = *transform;
1339     transform->_31 += baseline_origin.x * transform->_11 + baseline_origin.y * transform->_21;
1340     transform->_32 += baseline_origin.x * transform->_12 + baseline_origin.y * transform->_22;
1341     prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target);
1342     d2d_device_context_fill_geometry(render_target, unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)geometry),
1343             unsafe_impl_from_ID2D1Brush(brush), NULL);
1344     render_target->drawing_state.antialiasMode = prev_antialias_mode;
1345     *transform = prev_transform;
1346
1347     ID2D1PathGeometry_Release(geometry);
1348 }
1349
1350 static void d2d_device_context_draw_glyph_run_bitmap(struct d2d_device_context *render_target,
1351         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush,
1352         DWRITE_RENDERING_MODE rendering_mode, DWRITE_MEASURING_MODE measuring_mode,
1353         DWRITE_TEXT_ANTIALIAS_MODE antialias_mode)
1354 {
1355     ID2D1RectangleGeometry *geometry = NULL;
1356     ID2D1BitmapBrush *opacity_brush = NULL;
1357     D2D1_BITMAP_PROPERTIES bitmap_desc;
1358     ID2D1Bitmap *opacity_bitmap = NULL;
1359     IDWriteGlyphRunAnalysis *analysis;
1360     DWRITE_TEXTURE_TYPE texture_type;
1361     D2D1_BRUSH_PROPERTIES brush_desc;
1362     IDWriteFactory2 *dwrite_factory;
1363     D2D1_MATRIX_3X2_F *transform, m;
1364     void *opacity_values = NULL;
1365     size_t opacity_values_size;
1366     D2D1_SIZE_U bitmap_size;
1367     float scale_x, scale_y;
1368     D2D1_RECT_F run_rect;
1369     RECT bounds;
1370     HRESULT hr;
1371
1372     if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
1373             &IID_IDWriteFactory2, (IUnknown **)&dwrite_factory)))
1374     {
1375         ERR("Failed to create dwrite factory, hr %#lx.\n", hr);
1376         return;
1377     }
1378
1379     transform = &render_target->drawing_state.transform;
1380
1381     scale_x = render_target->desc.dpiX / 96.0f;
1382     m._11 = transform->_11 * scale_x;
1383     m._21 = transform->_21 * scale_x;
1384     m._31 = transform->_31 * scale_x;
1385
1386     scale_y = render_target->desc.dpiY / 96.0f;
1387     m._12 = transform->_12 * scale_y;
1388     m._22 = transform->_22 * scale_y;
1389     m._32 = transform->_32 * scale_y;
1390
1391     hr = IDWriteFactory2_CreateGlyphRunAnalysis(dwrite_factory, glyph_run, (DWRITE_MATRIX *)&m,
1392             rendering_mode, measuring_mode, DWRITE_GRID_FIT_MODE_DEFAULT, antialias_mode,
1393             baseline_origin.x, baseline_origin.y, &analysis);
1394     IDWriteFactory2_Release(dwrite_factory);
1395     if (FAILED(hr))
1396     {
1397         ERR("Failed to create glyph run analysis, hr %#lx.\n", hr);
1398         return;
1399     }
1400
1401     if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED || antialias_mode == DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE)
1402         texture_type = DWRITE_TEXTURE_ALIASED_1x1;
1403     else
1404         texture_type = DWRITE_TEXTURE_CLEARTYPE_3x1;
1405
1406     if (FAILED(hr = IDWriteGlyphRunAnalysis_GetAlphaTextureBounds(analysis, texture_type, &bounds)))
1407     {
1408         ERR("Failed to get alpha texture bounds, hr %#lx.\n", hr);
1409         goto done;
1410     }
1411
1412     d2d_size_set(&bitmap_size, bounds.right - bounds.left, bounds.bottom - bounds.top);
1413     if (!bitmap_size.width || !bitmap_size.height)
1414     {
1415         /* Empty run, nothing to do. */
1416         goto done;
1417     }
1418
1419     if (texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1)
1420         bitmap_size.width *= 3;
1421     if (!(opacity_values = calloc(bitmap_size.height, bitmap_size.width)))
1422     {
1423         ERR("Failed to allocate opacity values.\n");
1424         goto done;
1425     }
1426     opacity_values_size = bitmap_size.height * bitmap_size.width;
1427
1428     if (FAILED(hr = IDWriteGlyphRunAnalysis_CreateAlphaTexture(analysis,
1429             texture_type, &bounds, opacity_values, opacity_values_size)))
1430     {
1431         ERR("Failed to create alpha texture, hr %#lx.\n", hr);
1432         goto done;
1433     }
1434
1435     bitmap_desc.pixelFormat.format = DXGI_FORMAT_A8_UNORM;
1436     bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
1437     bitmap_desc.dpiX = render_target->desc.dpiX;
1438     if (texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1)
1439         bitmap_desc.dpiX *= 3.0f;
1440     bitmap_desc.dpiY = render_target->desc.dpiY;
1441     if (FAILED(hr = d2d_device_context_CreateBitmap(&render_target->ID2D1DeviceContext1_iface,
1442             bitmap_size, opacity_values, bitmap_size.width, &bitmap_desc, &opacity_bitmap)))
1443     {
1444         ERR("Failed to create opacity bitmap, hr %#lx.\n", hr);
1445         goto done;
1446     }
1447
1448     d2d_rect_set(&run_rect, bounds.left / scale_x, bounds.top / scale_y,
1449             bounds.right / scale_x, bounds.bottom / scale_y);
1450
1451     brush_desc.opacity = 1.0f;
1452     brush_desc.transform._11 = 1.0f;
1453     brush_desc.transform._12 = 0.0f;
1454     brush_desc.transform._21 = 0.0f;
1455     brush_desc.transform._22 = 1.0f;
1456     brush_desc.transform._31 = run_rect.left;
1457     brush_desc.transform._32 = run_rect.top;
1458     if (FAILED(hr = d2d_device_context_CreateBitmapBrush(&render_target->ID2D1DeviceContext1_iface,
1459             opacity_bitmap, NULL, &brush_desc, &opacity_brush)))
1460     {
1461         ERR("Failed to create opacity bitmap brush, hr %#lx.\n", hr);
1462         goto done;
1463     }
1464
1465     if (FAILED(hr = ID2D1Factory_CreateRectangleGeometry(render_target->factory, &run_rect, &geometry)))
1466     {
1467         ERR("Failed to create geometry, hr %#lx.\n", hr);
1468         goto done;
1469     }
1470
1471     m = *transform;
1472     *transform = identity;
1473     d2d_device_context_fill_geometry(render_target, unsafe_impl_from_ID2D1Geometry((ID2D1Geometry *)geometry),
1474             unsafe_impl_from_ID2D1Brush(brush), unsafe_impl_from_ID2D1Brush((ID2D1Brush *)opacity_brush));
1475     *transform = m;
1476
1477 done:
1478     if (geometry)
1479         ID2D1RectangleGeometry_Release(geometry);
1480     if (opacity_brush)
1481         ID2D1BitmapBrush_Release(opacity_brush);
1482     if (opacity_bitmap)
1483         ID2D1Bitmap_Release(opacity_bitmap);
1484     free(opacity_values);
1485     IDWriteGlyphRunAnalysis_Release(analysis);
1486 }
1487
1488 static void d2d_device_context_draw_glyph_run(struct d2d_device_context *context,
1489         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run,
1490         const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode)
1491 {
1492     DWRITE_TEXT_ANTIALIAS_MODE antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE;
1493     IDWriteRenderingParams *rendering_params;
1494     DWRITE_RENDERING_MODE rendering_mode;
1495     HRESULT hr;
1496
1497     if (FAILED(context->error.code))
1498         return;
1499
1500     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1501     {
1502         d2d_command_list_draw_glyph_run(context->target.command_list, context, baseline_origin, glyph_run,
1503                 glyph_run_desc, brush, measuring_mode);
1504         return;
1505     }
1506
1507     rendering_params = context->text_rendering_params ? context->text_rendering_params
1508             : context->default_text_rendering_params;
1509
1510     rendering_mode = IDWriteRenderingParams_GetRenderingMode(rendering_params);
1511
1512     switch (context->drawing_state.textAntialiasMode)
1513     {
1514         case D2D1_TEXT_ANTIALIAS_MODE_ALIASED:
1515             if (rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL
1516                     || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC
1517                     || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL
1518                     || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC)
1519                 d2d_device_context_set_error(context, E_INVALIDARG);
1520             break;
1521
1522         case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE:
1523             if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED
1524                     || rendering_mode == DWRITE_RENDERING_MODE_OUTLINE)
1525                 d2d_device_context_set_error(context, E_INVALIDARG);
1526             break;
1527
1528         case D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE:
1529             if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED)
1530                 d2d_device_context_set_error(context, E_INVALIDARG);
1531             break;
1532
1533         default:
1534             break;
1535     }
1536
1537     if (FAILED(context->error.code))
1538         return;
1539
1540     rendering_mode = DWRITE_RENDERING_MODE_DEFAULT;
1541     switch (context->drawing_state.textAntialiasMode)
1542     {
1543         case D2D1_TEXT_ANTIALIAS_MODE_DEFAULT:
1544             if (IDWriteRenderingParams_GetClearTypeLevel(rendering_params) > 0.0f)
1545                 antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE;
1546             break;
1547
1548         case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE:
1549             antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE;
1550             break;
1551
1552         case D2D1_TEXT_ANTIALIAS_MODE_ALIASED:
1553             rendering_mode = DWRITE_RENDERING_MODE_ALIASED;
1554             break;
1555
1556         default:
1557             break;
1558     }
1559
1560     if (rendering_mode == DWRITE_RENDERING_MODE_DEFAULT)
1561     {
1562         if (FAILED(hr = IDWriteFontFace_GetRecommendedRenderingMode(glyph_run->fontFace, glyph_run->fontEmSize,
1563                 max(context->desc.dpiX, context->desc.dpiY) / 96.0f,
1564                 measuring_mode, rendering_params, &rendering_mode)))
1565         {
1566             ERR("Failed to get recommended rendering mode, hr %#lx.\n", hr);
1567             rendering_mode = DWRITE_RENDERING_MODE_OUTLINE;
1568         }
1569     }
1570
1571     if (rendering_mode == DWRITE_RENDERING_MODE_OUTLINE)
1572         d2d_device_context_draw_glyph_run_outline(context, baseline_origin, glyph_run, brush);
1573     else
1574         d2d_device_context_draw_glyph_run_bitmap(context, baseline_origin, glyph_run, brush,
1575                 rendering_mode, measuring_mode, antialias_mode);
1576 }
1577
1578 static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext1 *iface,
1579         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush,
1580         DWRITE_MEASURING_MODE measuring_mode)
1581 {
1582     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1583
1584     TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n",
1585             iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode);
1586
1587     d2d_device_context_draw_glyph_run(context, baseline_origin, glyph_run, NULL, brush, measuring_mode);
1588 }
1589
1590 static void STDMETHODCALLTYPE d2d_device_context_SetTransform(ID2D1DeviceContext1 *iface,
1591         const D2D1_MATRIX_3X2_F *transform)
1592 {
1593     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1594
1595     TRACE("iface %p, transform %p.\n", iface, transform);
1596
1597     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1598         d2d_command_list_set_transform(context->target.command_list, transform);
1599
1600     context->drawing_state.transform = *transform;
1601 }
1602
1603 static void STDMETHODCALLTYPE d2d_device_context_GetTransform(ID2D1DeviceContext1 *iface,
1604         D2D1_MATRIX_3X2_F *transform)
1605 {
1606     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1607
1608     TRACE("iface %p, transform %p.\n", iface, transform);
1609
1610     *transform = render_target->drawing_state.transform;
1611 }
1612
1613 static void STDMETHODCALLTYPE d2d_device_context_SetAntialiasMode(ID2D1DeviceContext1 *iface,
1614         D2D1_ANTIALIAS_MODE antialias_mode)
1615 {
1616     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1617
1618     TRACE("iface %p, antialias_mode %#x stub!\n", iface, antialias_mode);
1619
1620     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1621         d2d_command_list_set_antialias_mode(context->target.command_list, antialias_mode);
1622
1623     context->drawing_state.antialiasMode = antialias_mode;
1624 }
1625
1626 static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_device_context_GetAntialiasMode(ID2D1DeviceContext1 *iface)
1627 {
1628     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1629
1630     TRACE("iface %p.\n", iface);
1631
1632     return render_target->drawing_state.antialiasMode;
1633 }
1634
1635 static void STDMETHODCALLTYPE d2d_device_context_SetTextAntialiasMode(ID2D1DeviceContext1 *iface,
1636         D2D1_TEXT_ANTIALIAS_MODE antialias_mode)
1637 {
1638     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1639
1640     TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode);
1641
1642     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1643         d2d_command_list_set_text_antialias_mode(context->target.command_list, antialias_mode);
1644
1645     context->drawing_state.textAntialiasMode = antialias_mode;
1646 }
1647
1648 static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_device_context_GetTextAntialiasMode(ID2D1DeviceContext1 *iface)
1649 {
1650     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1651
1652     TRACE("iface %p.\n", iface);
1653
1654     return render_target->drawing_state.textAntialiasMode;
1655 }
1656
1657 static void STDMETHODCALLTYPE d2d_device_context_SetTextRenderingParams(ID2D1DeviceContext1 *iface,
1658         IDWriteRenderingParams *text_rendering_params)
1659 {
1660     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1661
1662     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
1663
1664     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1665         d2d_command_list_set_text_rendering_params(context->target.command_list, text_rendering_params);
1666
1667     if (text_rendering_params)
1668         IDWriteRenderingParams_AddRef(text_rendering_params);
1669     if (context->text_rendering_params)
1670         IDWriteRenderingParams_Release(context->text_rendering_params);
1671     context->text_rendering_params = text_rendering_params;
1672 }
1673
1674 static void STDMETHODCALLTYPE d2d_device_context_GetTextRenderingParams(ID2D1DeviceContext1 *iface,
1675         IDWriteRenderingParams **text_rendering_params)
1676 {
1677     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1678
1679     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
1680
1681     if ((*text_rendering_params = render_target->text_rendering_params))
1682         IDWriteRenderingParams_AddRef(*text_rendering_params);
1683 }
1684
1685 static void STDMETHODCALLTYPE d2d_device_context_SetTags(ID2D1DeviceContext1 *iface, D2D1_TAG tag1, D2D1_TAG tag2)
1686 {
1687     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1688
1689     TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2));
1690
1691     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1692         d2d_command_list_set_tags(context->target.command_list, tag1, tag2);
1693
1694     context->drawing_state.tag1 = tag1;
1695     context->drawing_state.tag2 = tag2;
1696 }
1697
1698 static void STDMETHODCALLTYPE d2d_device_context_GetTags(ID2D1DeviceContext1 *iface, D2D1_TAG *tag1, D2D1_TAG *tag2)
1699 {
1700     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1701
1702     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
1703
1704     *tag1 = render_target->drawing_state.tag1;
1705     *tag2 = render_target->drawing_state.tag2;
1706 }
1707
1708 static void STDMETHODCALLTYPE d2d_device_context_PushLayer(ID2D1DeviceContext1 *iface,
1709         const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer)
1710 {
1711     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1712
1713     FIXME("iface %p, layer_parameters %p, layer %p stub!\n", iface, layer_parameters, layer);
1714
1715     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1716     {
1717         D2D1_LAYER_PARAMETERS1 parameters;
1718
1719         memcpy(&parameters, layer_parameters, sizeof(*layer_parameters));
1720         parameters.layerOptions = D2D1_LAYER_OPTIONS1_NONE;
1721         d2d_command_list_push_layer(context->target.command_list, context, &parameters, layer);
1722     }
1723 }
1724
1725 static void STDMETHODCALLTYPE d2d_device_context_PopLayer(ID2D1DeviceContext1 *iface)
1726 {
1727     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1728
1729     FIXME("iface %p stub!\n", iface);
1730
1731     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1732         d2d_command_list_pop_layer(context->target.command_list);
1733 }
1734
1735 static HRESULT STDMETHODCALLTYPE d2d_device_context_Flush(ID2D1DeviceContext1 *iface, D2D1_TAG *tag1, D2D1_TAG *tag2)
1736 {
1737     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1738
1739     FIXME("iface %p, tag1 %p, tag2 %p stub!\n", iface, tag1, tag2);
1740
1741     if (context->ops && context->ops->device_context_present)
1742         context->ops->device_context_present(context->outer_unknown);
1743
1744     return E_NOTIMPL;
1745 }
1746
1747 static void STDMETHODCALLTYPE d2d_device_context_SaveDrawingState(ID2D1DeviceContext1 *iface,
1748         ID2D1DrawingStateBlock *state_block)
1749 {
1750     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1751     struct d2d_state_block *state_block_impl;
1752
1753     TRACE("iface %p, state_block %p.\n", iface, state_block);
1754
1755     if (!(state_block_impl = unsafe_impl_from_ID2D1DrawingStateBlock(state_block))) return;
1756     state_block_impl->drawing_state = render_target->drawing_state;
1757     if (render_target->text_rendering_params)
1758         IDWriteRenderingParams_AddRef(render_target->text_rendering_params);
1759     if (state_block_impl->text_rendering_params)
1760         IDWriteRenderingParams_Release(state_block_impl->text_rendering_params);
1761     state_block_impl->text_rendering_params = render_target->text_rendering_params;
1762 }
1763
1764 static void STDMETHODCALLTYPE d2d_device_context_RestoreDrawingState(ID2D1DeviceContext1 *iface,
1765         ID2D1DrawingStateBlock *state_block)
1766 {
1767     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1768     struct d2d_state_block *state_block_impl;
1769
1770     TRACE("iface %p, state_block %p.\n", iface, state_block);
1771
1772     if (!(state_block_impl = unsafe_impl_from_ID2D1DrawingStateBlock(state_block))) return;
1773     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1774     {
1775         struct d2d_command_list *command_list = context->target.command_list;
1776
1777         if (context->drawing_state.antialiasMode != state_block_impl->drawing_state.antialiasMode)
1778             d2d_command_list_set_antialias_mode(command_list, state_block_impl->drawing_state.antialiasMode);
1779         d2d_command_list_set_text_antialias_mode(command_list, state_block_impl->drawing_state.textAntialiasMode);
1780         d2d_command_list_set_tags(command_list, state_block_impl->drawing_state.tag1, state_block_impl->drawing_state.tag2);
1781         d2d_command_list_set_transform(command_list, &state_block_impl->drawing_state.transform);
1782         d2d_command_list_set_primitive_blend(command_list, state_block_impl->drawing_state.primitiveBlend);
1783         d2d_command_list_set_unit_mode(command_list, state_block_impl->drawing_state.unitMode);
1784         d2d_command_list_set_text_rendering_params(command_list, state_block_impl->text_rendering_params);
1785     }
1786
1787     context->drawing_state = state_block_impl->drawing_state;
1788     if (state_block_impl->text_rendering_params)
1789         IDWriteRenderingParams_AddRef(state_block_impl->text_rendering_params);
1790     if (context->text_rendering_params)
1791         IDWriteRenderingParams_Release(context->text_rendering_params);
1792     context->text_rendering_params = state_block_impl->text_rendering_params;
1793 }
1794
1795 static void STDMETHODCALLTYPE d2d_device_context_PushAxisAlignedClip(ID2D1DeviceContext1 *iface,
1796         const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode)
1797 {
1798     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1799     D2D1_RECT_F transformed_rect;
1800     float x_scale, y_scale;
1801     D2D1_POINT_2F point;
1802
1803     TRACE("iface %p, clip_rect %s, antialias_mode %#x.\n", iface, debug_d2d_rect_f(clip_rect), antialias_mode);
1804
1805     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1806         d2d_command_list_push_clip(context->target.command_list, clip_rect, antialias_mode);
1807
1808     if (antialias_mode != D2D1_ANTIALIAS_MODE_ALIASED)
1809         FIXME("Ignoring antialias_mode %#x.\n", antialias_mode);
1810
1811     x_scale = context->desc.dpiX / 96.0f;
1812     y_scale = context->desc.dpiY / 96.0f;
1813     d2d_point_transform(&point, &context->drawing_state.transform,
1814             clip_rect->left * x_scale, clip_rect->top * y_scale);
1815     d2d_rect_set(&transformed_rect, point.x, point.y, point.x, point.y);
1816     d2d_point_transform(&point, &context->drawing_state.transform,
1817             clip_rect->left * x_scale, clip_rect->bottom * y_scale);
1818     d2d_rect_expand(&transformed_rect, &point);
1819     d2d_point_transform(&point, &context->drawing_state.transform,
1820             clip_rect->right * x_scale, clip_rect->top * y_scale);
1821     d2d_rect_expand(&transformed_rect, &point);
1822     d2d_point_transform(&point, &context->drawing_state.transform,
1823             clip_rect->right * x_scale, clip_rect->bottom * y_scale);
1824     d2d_rect_expand(&transformed_rect, &point);
1825
1826     if (!d2d_clip_stack_push(&context->clip_stack, &transformed_rect))
1827         WARN("Failed to push clip rect.\n");
1828 }
1829
1830 static void STDMETHODCALLTYPE d2d_device_context_PopAxisAlignedClip(ID2D1DeviceContext1 *iface)
1831 {
1832     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1833
1834     TRACE("iface %p.\n", iface);
1835
1836     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1837         d2d_command_list_pop_clip(context->target.command_list);
1838
1839     d2d_clip_stack_pop(&context->clip_stack);
1840 }
1841
1842 static void STDMETHODCALLTYPE d2d_device_context_Clear(ID2D1DeviceContext1 *iface, const D2D1_COLOR_F *colour)
1843 {
1844     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1845     D3D11_MAPPED_SUBRESOURCE map_desc;
1846     ID3D11DeviceContext *d3d_context;
1847     struct d2d_ps_cb *ps_cb_data;
1848     struct d2d_vs_cb *vs_cb_data;
1849     D2D1_COLOR_F *c;
1850     HRESULT hr;
1851
1852     TRACE("iface %p, colour %p.\n", iface, colour);
1853
1854     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1855     {
1856         d2d_command_list_clear(context->target.command_list, colour);
1857         return;
1858     }
1859
1860     ID3D11Device1_GetImmediateContext(context->d3d_device, &d3d_context);
1861
1862     if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->vs_cb,
1863             0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc)))
1864     {
1865         WARN("Failed to map vs constant buffer, hr %#lx.\n", hr);
1866         ID3D11DeviceContext_Release(d3d_context);
1867         return;
1868     }
1869
1870     vs_cb_data = map_desc.pData;
1871     vs_cb_data->transform_geometry._11 = 1.0f;
1872     vs_cb_data->transform_geometry._21 = 0.0f;
1873     vs_cb_data->transform_geometry._31 = 0.0f;
1874     vs_cb_data->transform_geometry.pad0 = 0.0f;
1875     vs_cb_data->transform_geometry._12 = 0.0f;
1876     vs_cb_data->transform_geometry._22 = 1.0f;
1877     vs_cb_data->transform_geometry._32 = 0.0f;
1878     vs_cb_data->transform_geometry.stroke_width = 0.0f;
1879     vs_cb_data->transform_rtx.x = 1.0f;
1880     vs_cb_data->transform_rtx.y = 0.0f;
1881     vs_cb_data->transform_rtx.z = 1.0f;
1882     vs_cb_data->transform_rtx.w = 1.0f;
1883     vs_cb_data->transform_rty.x = 0.0f;
1884     vs_cb_data->transform_rty.y = 1.0f;
1885     vs_cb_data->transform_rty.z = 1.0f;
1886     vs_cb_data->transform_rty.w = -1.0f;
1887
1888     ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->vs_cb, 0);
1889
1890     if (FAILED(hr = ID3D11DeviceContext_Map(d3d_context, (ID3D11Resource *)context->ps_cb,
1891             0, D3D11_MAP_WRITE_DISCARD, 0, &map_desc)))
1892     {
1893         WARN("Failed to map ps constant buffer, hr %#lx.\n", hr);
1894         ID3D11DeviceContext_Release(d3d_context);
1895         return;
1896     }
1897
1898     ps_cb_data = map_desc.pData;
1899     memset(ps_cb_data, 0, sizeof(*ps_cb_data));
1900     ps_cb_data->colour_brush.type = D2D_BRUSH_TYPE_SOLID;
1901     ps_cb_data->colour_brush.opacity = 1.0f;
1902     ps_cb_data->opacity_brush.type = D2D_BRUSH_TYPE_COUNT;
1903     c = &ps_cb_data->colour_brush.u.solid.colour;
1904     if (colour)
1905         *c = *colour;
1906     if (context->desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE)
1907         c->a = 1.0f;
1908     c->r *= c->a;
1909     c->g *= c->a;
1910     c->b *= c->a;
1911
1912     ID3D11DeviceContext_Unmap(d3d_context, (ID3D11Resource *)context->ps_cb, 0);
1913     ID3D11DeviceContext_Release(d3d_context);
1914
1915     d2d_device_context_draw(context, D2D_SHAPE_TYPE_TRIANGLE, context->ib, 6,
1916             context->vb, context->vb_stride, NULL, NULL);
1917 }
1918
1919 static void STDMETHODCALLTYPE d2d_device_context_BeginDraw(ID2D1DeviceContext1 *iface)
1920 {
1921     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1922
1923     TRACE("iface %p.\n", iface);
1924
1925     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1926         d2d_command_list_begin_draw(context->target.command_list, context);
1927
1928     memset(&context->error, 0, sizeof(context->error));
1929 }
1930
1931 static HRESULT STDMETHODCALLTYPE d2d_device_context_EndDraw(ID2D1DeviceContext1 *iface,
1932         D2D1_TAG *tag1, D2D1_TAG *tag2)
1933 {
1934     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
1935     HRESULT hr;
1936
1937     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
1938
1939     if (context->target.type == D2D_TARGET_COMMAND_LIST)
1940     {
1941         FIXME("Unimplemented for command list target.\n");
1942         return E_NOTIMPL;
1943     }
1944
1945     if (tag1)
1946         *tag1 = context->error.tag1;
1947     if (tag2)
1948         *tag2 = context->error.tag2;
1949
1950     if (context->ops && context->ops->device_context_present)
1951     {
1952         if (FAILED(hr = context->ops->device_context_present(context->outer_unknown)))
1953             context->error.code = hr;
1954     }
1955
1956     return context->error.code;
1957 }
1958
1959 static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_device_context_GetPixelFormat(ID2D1DeviceContext1 *iface,
1960         D2D1_PIXEL_FORMAT *format)
1961 {
1962     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1963
1964     TRACE("iface %p, format %p.\n", iface, format);
1965
1966     *format = render_target->desc.pixelFormat;
1967     return format;
1968 }
1969
1970 static void STDMETHODCALLTYPE d2d_device_context_SetDpi(ID2D1DeviceContext1 *iface, float dpi_x, float dpi_y)
1971 {
1972     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1973
1974     TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y);
1975
1976     if (dpi_x == 0.0f && dpi_y == 0.0f)
1977     {
1978         dpi_x = 96.0f;
1979         dpi_y = 96.0f;
1980     }
1981     else if (dpi_x <= 0.0f || dpi_y <= 0.0f)
1982         return;
1983
1984     render_target->desc.dpiX = dpi_x;
1985     render_target->desc.dpiY = dpi_y;
1986 }
1987
1988 static void STDMETHODCALLTYPE d2d_device_context_GetDpi(ID2D1DeviceContext1 *iface, float *dpi_x, float *dpi_y)
1989 {
1990     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
1991
1992     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
1993
1994     *dpi_x = render_target->desc.dpiX;
1995     *dpi_y = render_target->desc.dpiY;
1996 }
1997
1998 static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_device_context_GetSize(ID2D1DeviceContext1 *iface, D2D1_SIZE_F *size)
1999 {
2000     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
2001
2002     TRACE("iface %p, size %p.\n", iface, size);
2003
2004     size->width = render_target->pixel_size.width / (render_target->desc.dpiX / 96.0f);
2005     size->height = render_target->pixel_size.height / (render_target->desc.dpiY / 96.0f);
2006     return size;
2007 }
2008
2009 static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_device_context_GetPixelSize(ID2D1DeviceContext1 *iface,
2010         D2D1_SIZE_U *pixel_size)
2011 {
2012     struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface);
2013
2014     TRACE("iface %p, pixel_size %p.\n", iface, pixel_size);
2015
2016     *pixel_size = render_target->pixel_size;
2017     return pixel_size;
2018 }
2019
2020 static UINT32 STDMETHODCALLTYPE d2d_device_context_GetMaximumBitmapSize(ID2D1DeviceContext1 *iface)
2021 {
2022     TRACE("iface %p.\n", iface);
2023
2024     return D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
2025 }
2026
2027 static BOOL STDMETHODCALLTYPE d2d_device_context_IsSupported(ID2D1DeviceContext1 *iface,
2028         const D2D1_RENDER_TARGET_PROPERTIES *desc)
2029 {
2030     FIXME("iface %p, desc %p stub!\n", iface, desc);
2031
2032     return FALSE;
2033 }
2034
2035 static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmap(ID2D1DeviceContext1 *iface,
2036         D2D1_SIZE_U size, const void *src_data, UINT32 pitch,
2037         const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap)
2038 {
2039     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2040     struct d2d_bitmap *object;
2041     HRESULT hr;
2042
2043     TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n",
2044             iface, size.width, size.height, src_data, pitch, desc, bitmap);
2045
2046     if (SUCCEEDED(hr = d2d_bitmap_create(context, size, src_data, pitch, desc, &object)))
2047         *bitmap = &object->ID2D1Bitmap1_iface;
2048
2049     return hr;
2050 }
2051
2052 static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap(
2053         ID2D1DeviceContext1 *iface, IWICBitmapSource *bitmap_source,
2054         const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap)
2055 {
2056     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2057     struct d2d_bitmap *object;
2058     HRESULT hr;
2059
2060     TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n", iface, bitmap_source, desc, bitmap);
2061
2062     if (SUCCEEDED(hr = d2d_bitmap_create_from_wic_bitmap(context, bitmap_source, desc, &object)))
2063         *bitmap = &object->ID2D1Bitmap1_iface;
2064
2065     return hr;
2066 }
2067
2068 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContext(ID2D1DeviceContext1 *iface,
2069         D2D1_COLOR_SPACE space, const BYTE *profile, UINT32 profile_size, ID2D1ColorContext **color_context)
2070 {
2071     FIXME("iface %p, space %#x, profile %p, profile_size %u, color_context %p stub!\n",
2072             iface, space, profile, profile_size, color_context);
2073
2074     return E_NOTIMPL;
2075 }
2076
2077 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromFilename(ID2D1DeviceContext1 *iface,
2078         const WCHAR *filename, ID2D1ColorContext **color_context)
2079 {
2080     FIXME("iface %p, filename %s, color_context %p stub!\n", iface, debugstr_w(filename), color_context);
2081
2082     return E_NOTIMPL;
2083 }
2084
2085 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateColorContextFromWicColorContext(ID2D1DeviceContext1 *iface,
2086         IWICColorContext *wic_color_context, ID2D1ColorContext **color_context)
2087 {
2088     FIXME("iface %p, wic_color_context %p, color_context %p stub!\n", iface, wic_color_context, color_context);
2089
2090     return E_NOTIMPL;
2091 }
2092
2093 static BOOL d2d_bitmap_check_options_with_surface(unsigned int options, unsigned int surface_options)
2094 {
2095     switch (options)
2096     {
2097         case D2D1_BITMAP_OPTIONS_NONE:
2098         case D2D1_BITMAP_OPTIONS_TARGET:
2099         case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW:
2100         case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE:
2101         case D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE:
2102         case D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ:
2103         case D2D1_BITMAP_OPTIONS_CANNOT_DRAW:
2104             break;
2105         default:
2106             WARN("Invalid bitmap options %#x.\n", options);
2107             return FALSE;
2108     }
2109
2110     if (options && (options & D2D1_BITMAP_OPTIONS_TARGET) != (surface_options & D2D1_BITMAP_OPTIONS_TARGET))
2111         return FALSE;
2112     if (!(options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW) && (surface_options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
2113         return FALSE;
2114     if (options & D2D1_BITMAP_OPTIONS_TARGET)
2115     {
2116         if (options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE && !(surface_options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE))
2117             return FALSE;
2118         return TRUE;
2119     }
2120
2121     if (options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW)
2122     {
2123         if (!(surface_options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
2124             return FALSE;
2125
2126         if (options & D2D1_BITMAP_OPTIONS_CPU_READ && !(surface_options & D2D1_BITMAP_OPTIONS_CPU_READ))
2127             return FALSE;
2128     }
2129
2130     return TRUE;
2131 }
2132
2133 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateBitmapFromDxgiSurface(ID2D1DeviceContext1 *iface,
2134         IDXGISurface *surface, const D2D1_BITMAP_PROPERTIES1 *desc, ID2D1Bitmap1 **bitmap)
2135 {
2136     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2137     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
2138     unsigned int surface_options;
2139     struct d2d_bitmap *object;
2140     HRESULT hr;
2141
2142     TRACE("iface %p, surface %p, desc %p, bitmap %p.\n", iface, surface, desc, bitmap);
2143
2144     surface_options = d2d_get_bitmap_options_for_surface(surface);
2145
2146     if (desc)
2147     {
2148         if (!d2d_bitmap_check_options_with_surface(desc->bitmapOptions, surface_options))
2149         {
2150             WARN("Incompatible bitmap options %#x, surface options %#x.\n",
2151                     desc->bitmapOptions, surface_options);
2152             return E_INVALIDARG;
2153         }
2154     }
2155     else
2156     {
2157         DXGI_SURFACE_DESC surface_desc;
2158
2159         if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc)))
2160         {
2161             WARN("Failed to get surface desc, hr %#lx.\n", hr);
2162             return hr;
2163         }
2164
2165         memset(&bitmap_desc, 0, sizeof(bitmap_desc));
2166         bitmap_desc.pixelFormat.format = surface_desc.Format;
2167         bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
2168         bitmap_desc.bitmapOptions = surface_options;
2169         desc = &bitmap_desc;
2170     }
2171
2172     if (SUCCEEDED(hr = d2d_bitmap_create_shared(context, &IID_IDXGISurface, surface, desc, &object)))
2173         *bitmap = &object->ID2D1Bitmap1_iface;
2174
2175     return hr;
2176 }
2177
2178 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateEffect(ID2D1DeviceContext1 *iface,
2179         REFCLSID effect_id, ID2D1Effect **effect)
2180 {
2181     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2182
2183     TRACE("iface %p, effect_id %s, effect %p.\n", iface, debugstr_guid(effect_id), effect);
2184
2185     return d2d_effect_create(context, effect_id, effect);
2186 }
2187
2188 static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateGradientStopCollection(
2189         ID2D1DeviceContext1 *iface, const D2D1_GRADIENT_STOP *stops, UINT32 stop_count,
2190         D2D1_COLOR_SPACE preinterpolation_space, D2D1_COLOR_SPACE postinterpolation_space,
2191         D2D1_BUFFER_PRECISION buffer_precision, D2D1_EXTEND_MODE extend_mode,
2192         D2D1_COLOR_INTERPOLATION_MODE color_interpolation_mode, ID2D1GradientStopCollection1 **gradient)
2193 {
2194     FIXME("iface %p, stops %p, stop_count %u, preinterpolation_space %#x, postinterpolation_space %#x, "
2195             "buffer_precision %#x, extend_mode %#x, color_interpolation_mode %#x, gradient %p stub!\n",
2196             iface, stops, stop_count, preinterpolation_space, postinterpolation_space,
2197             buffer_precision, extend_mode, color_interpolation_mode, gradient);
2198
2199     return E_NOTIMPL;
2200 }
2201
2202 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateImageBrush(ID2D1DeviceContext1 *iface,
2203         ID2D1Image *image, const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc,
2204         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1ImageBrush **brush)
2205 {
2206     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2207     struct d2d_brush *object;
2208     HRESULT hr;
2209
2210     TRACE("iface %p, image %p, image_brush_desc %p, brush_desc %p, brush %p.\n", iface, image, image_brush_desc,
2211             brush_desc, brush);
2212
2213     if (SUCCEEDED(hr = d2d_image_brush_create(context->factory, image, image_brush_desc,
2214             brush_desc, &object)))
2215         *brush = (ID2D1ImageBrush *)&object->ID2D1Brush_iface;
2216
2217     return hr;
2218 }
2219
2220 static HRESULT STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_CreateBitmapBrush(ID2D1DeviceContext1 *iface,
2221         ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc,
2222         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush1 **brush)
2223 {
2224     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2225     struct d2d_brush *object;
2226     HRESULT hr;
2227
2228     TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n", iface, bitmap, bitmap_brush_desc,
2229             brush_desc, brush);
2230
2231     if (SUCCEEDED(hr = d2d_bitmap_brush_create(context->factory, bitmap, bitmap_brush_desc, brush_desc, &object)))
2232         *brush = (ID2D1BitmapBrush1 *)&object->ID2D1Brush_iface;
2233
2234     return hr;
2235 }
2236
2237 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateCommandList(ID2D1DeviceContext1 *iface,
2238         ID2D1CommandList **command_list)
2239 {
2240     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2241     struct d2d_command_list *object;
2242     HRESULT hr;
2243
2244     TRACE("iface %p, command_list %p.\n", iface, command_list);
2245
2246     if (SUCCEEDED(hr = d2d_command_list_create(context->factory, &object)))
2247         *command_list = &object->ID2D1CommandList_iface;
2248
2249     return hr;
2250 }
2251
2252 static BOOL STDMETHODCALLTYPE d2d_device_context_IsDxgiFormatSupported(ID2D1DeviceContext1 *iface, DXGI_FORMAT format)
2253 {
2254     FIXME("iface %p, format %#x stub!\n", iface, format);
2255
2256     return FALSE;
2257 }
2258
2259 static BOOL STDMETHODCALLTYPE d2d_device_context_IsBufferPrecisionSupported(ID2D1DeviceContext1 *iface,
2260         D2D1_BUFFER_PRECISION buffer_precision)
2261 {
2262     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2263     DXGI_FORMAT format;
2264     UINT support = 0;
2265     HRESULT hr;
2266
2267     TRACE("iface %p, buffer_precision %u.\n", iface, buffer_precision);
2268
2269     switch (buffer_precision)
2270     {
2271         case D2D1_BUFFER_PRECISION_8BPC_UNORM: format = DXGI_FORMAT_R8G8B8A8_UNORM; break;
2272         case D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB: format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; break;
2273         case D2D1_BUFFER_PRECISION_16BPC_UNORM: format = DXGI_FORMAT_R16G16B16A16_UNORM; break;
2274         case D2D1_BUFFER_PRECISION_16BPC_FLOAT: format = DXGI_FORMAT_R16G16B16A16_FLOAT; break;
2275         case D2D1_BUFFER_PRECISION_32BPC_FLOAT: format = DXGI_FORMAT_R32G32B32A32_FLOAT; break;
2276         default:
2277             WARN("Unexpected precision %u.\n", buffer_precision);
2278             return FALSE;
2279     }
2280
2281     if (FAILED(hr = ID3D11Device1_CheckFormatSupport(context->d3d_device, format, &support)))
2282     {
2283         WARN("Format support check failed, hr %#lx.\n", hr);
2284     }
2285
2286     return !!(support & D3D11_FORMAT_SUPPORT_BUFFER);
2287 }
2288
2289 static void STDMETHODCALLTYPE d2d_device_context_GetImageLocalBounds(ID2D1DeviceContext1 *iface,
2290         ID2D1Image *image, D2D1_RECT_F *local_bounds)
2291 {
2292     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2293     D2D_SIZE_U pixel_size;
2294     ID2D1Bitmap *bitmap;
2295     D2D_SIZE_F size;
2296
2297     TRACE("iface %p, image %p, local_bounds %p.\n", iface, image, local_bounds);
2298
2299     if (SUCCEEDED(ID2D1Image_QueryInterface(image, &IID_ID2D1Bitmap, (void **)&bitmap)))
2300     {
2301         local_bounds->left = 0.0f;
2302         local_bounds->top  = 0.0f;
2303         switch (context->drawing_state.unitMode)
2304         {
2305             case D2D1_UNIT_MODE_DIPS:
2306                 size = ID2D1Bitmap_GetSize(bitmap);
2307                 local_bounds->right  = size.width;
2308                 local_bounds->bottom = size.height;
2309                 break;
2310
2311             case D2D1_UNIT_MODE_PIXELS:
2312                 pixel_size = ID2D1Bitmap_GetPixelSize(bitmap);
2313                 local_bounds->right  = pixel_size.width;
2314                 local_bounds->bottom = pixel_size.height;
2315                 break;
2316
2317             default:
2318                 WARN("Unknown unit mode %#x.\n", context->drawing_state.unitMode);
2319                 break;
2320         }
2321         ID2D1Bitmap_Release(bitmap);
2322     }
2323     else
2324     {
2325         FIXME("Unable to get local bounds of image %p.\n", image);
2326     }
2327 }
2328
2329 static HRESULT STDMETHODCALLTYPE d2d_device_context_GetImageWorldBounds(ID2D1DeviceContext1 *iface,
2330         ID2D1Image *image, D2D1_RECT_F *world_bounds)
2331 {
2332     FIXME("iface %p, image %p, world_bounds %p stub!\n", iface, image, world_bounds);
2333
2334     return E_NOTIMPL;
2335 }
2336
2337 static HRESULT STDMETHODCALLTYPE d2d_device_context_GetGlyphRunWorldBounds(ID2D1DeviceContext1 *iface,
2338         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run,
2339         DWRITE_MEASURING_MODE measuring_mode, D2D1_RECT_F *bounds)
2340 {
2341     FIXME("iface %p, baseline_origin %s, glyph_run %p, measuring_mode %#x, bounds %p stub!\n",
2342             iface, debug_d2d_point_2f(&baseline_origin), glyph_run, measuring_mode, bounds);
2343
2344     return E_NOTIMPL;
2345 }
2346
2347 static void STDMETHODCALLTYPE d2d_device_context_GetDevice(ID2D1DeviceContext1 *iface, ID2D1Device **device)
2348 {
2349     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2350
2351     TRACE("iface %p, device %p.\n", iface, device);
2352
2353     *device = (ID2D1Device *)&context->device->ID2D1Device1_iface;
2354     ID2D1Device_AddRef(*device);
2355 }
2356
2357 static void d2d_device_context_reset_target(struct d2d_device_context *context)
2358 {
2359     if (!context->target.object)
2360         return;
2361
2362     IUnknown_Release(context->target.object);
2363     memset(&context->target, 0, sizeof(context->target));
2364
2365     /* Note that DPI settings are kept. */
2366     memset(&context->desc.pixelFormat, 0, sizeof(context->desc.pixelFormat));
2367     memset(&context->pixel_size, 0, sizeof(context->pixel_size));
2368
2369     if (context->bs)
2370         ID3D11BlendState_Release(context->bs);
2371     context->bs = NULL;
2372 }
2373
2374 static void STDMETHODCALLTYPE d2d_device_context_SetTarget(ID2D1DeviceContext1 *iface, ID2D1Image *target)
2375 {
2376     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2377     struct d2d_command_list *command_list_impl;
2378     struct d2d_bitmap *bitmap_impl;
2379     ID2D1CommandList *command_list;
2380     D3D11_BLEND_DESC blend_desc;
2381     ID2D1Bitmap *bitmap;
2382     HRESULT hr;
2383
2384     TRACE("iface %p, target %p.\n", iface, target);
2385
2386     if (!target)
2387     {
2388         d2d_device_context_reset_target(context);
2389         return;
2390     }
2391
2392     if (SUCCEEDED(ID2D1Image_QueryInterface(target, &IID_ID2D1Bitmap, (void **)&bitmap)))
2393     {
2394         bitmap_impl = unsafe_impl_from_ID2D1Bitmap(bitmap);
2395
2396         if (!(bitmap_impl->options & D2D1_BITMAP_OPTIONS_TARGET))
2397         {
2398             ID2D1Bitmap_Release(bitmap);
2399             d2d_device_context_set_error(context, D2DERR_INVALID_TARGET);
2400             return;
2401         }
2402
2403         d2d_device_context_reset_target(context);
2404
2405         /* Set sizes and pixel format. */
2406         context->pixel_size = bitmap_impl->pixel_size;
2407         context->desc.pixelFormat = bitmap_impl->format;
2408         context->target.bitmap = bitmap_impl;
2409         context->target.object = target;
2410         context->target.type = D2D_TARGET_BITMAP;
2411
2412         memset(&blend_desc, 0, sizeof(blend_desc));
2413         blend_desc.IndependentBlendEnable = FALSE;
2414         blend_desc.RenderTarget[0].BlendEnable = TRUE;
2415         blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
2416         blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
2417         blend_desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
2418         blend_desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
2419         blend_desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
2420         blend_desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
2421         blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
2422         if (FAILED(hr = ID3D11Device1_CreateBlendState(context->d3d_device, &blend_desc, &context->bs)))
2423             WARN("Failed to create blend state, hr %#lx.\n", hr);
2424     }
2425     else if (SUCCEEDED(ID2D1Image_QueryInterface(target, &IID_ID2D1CommandList, (void **)&command_list)))
2426     {
2427         command_list_impl = unsafe_impl_from_ID2D1CommandList(command_list);
2428
2429         d2d_device_context_reset_target(context);
2430
2431         context->target.command_list = command_list_impl;
2432         context->target.object = target;
2433         context->target.type = D2D_TARGET_COMMAND_LIST;
2434     }
2435     else
2436     {
2437         WARN("Unsupported target type.\n");
2438     }
2439 }
2440
2441 static void STDMETHODCALLTYPE d2d_device_context_GetTarget(ID2D1DeviceContext1 *iface, ID2D1Image **target)
2442 {
2443     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2444
2445     TRACE("iface %p, target %p.\n", iface, target);
2446
2447     *target = context->target.object ? context->target.object : NULL;
2448     if (*target)
2449         ID2D1Image_AddRef(*target);
2450 }
2451
2452 static void STDMETHODCALLTYPE d2d_device_context_SetRenderingControls(ID2D1DeviceContext1 *iface,
2453         const D2D1_RENDERING_CONTROLS *rendering_controls)
2454 {
2455     FIXME("iface %p, rendering_controls %p stub!\n", iface, rendering_controls);
2456 }
2457
2458 static void STDMETHODCALLTYPE d2d_device_context_GetRenderingControls(ID2D1DeviceContext1 *iface,
2459         D2D1_RENDERING_CONTROLS *rendering_controls)
2460 {
2461     FIXME("iface %p, rendering_controls %p stub!\n", iface, rendering_controls);
2462 }
2463
2464 static void STDMETHODCALLTYPE d2d_device_context_SetPrimitiveBlend(ID2D1DeviceContext1 *iface,
2465         D2D1_PRIMITIVE_BLEND primitive_blend)
2466 {
2467     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2468
2469     TRACE("iface %p, primitive_blend %u.\n", iface, primitive_blend);
2470
2471     if (primitive_blend > D2D1_PRIMITIVE_BLEND_MAX)
2472     {
2473         WARN("Unknown blend mode %u.\n", primitive_blend);
2474         return;
2475     }
2476
2477     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2478         d2d_command_list_set_primitive_blend(context->target.command_list, primitive_blend);
2479
2480     context->drawing_state.primitiveBlend = primitive_blend;
2481 }
2482
2483 static D2D1_PRIMITIVE_BLEND STDMETHODCALLTYPE d2d_device_context_GetPrimitiveBlend(ID2D1DeviceContext1 *iface)
2484 {
2485     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2486
2487     TRACE("iface %p.\n", iface);
2488
2489     return context->drawing_state.primitiveBlend;
2490 }
2491
2492 static void STDMETHODCALLTYPE d2d_device_context_SetUnitMode(ID2D1DeviceContext1 *iface, D2D1_UNIT_MODE unit_mode)
2493 {
2494     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2495
2496     TRACE("iface %p, unit_mode %#x.\n", iface, unit_mode);
2497
2498     if (unit_mode != D2D1_UNIT_MODE_DIPS && unit_mode != D2D1_UNIT_MODE_PIXELS)
2499     {
2500         WARN("Unknown unit mode %#x.\n", unit_mode);
2501         return;
2502     }
2503
2504     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2505         d2d_command_list_set_unit_mode(context->target.command_list, unit_mode);
2506
2507     context->drawing_state.unitMode = unit_mode;
2508 }
2509
2510 static D2D1_UNIT_MODE STDMETHODCALLTYPE d2d_device_context_GetUnitMode(ID2D1DeviceContext1 *iface)
2511 {
2512     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2513
2514     TRACE("iface %p.\n", iface);
2515
2516     return context->drawing_state.unitMode;
2517 }
2518
2519 static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawGlyphRun(ID2D1DeviceContext1 *iface,
2520         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run,
2521         const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode)
2522 {
2523     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2524
2525     TRACE("iface %p, baseline_origin %s, glyph_run %p, glyph_run_desc %p, brush %p, measuring_mode %#x.\n",
2526             iface, debug_d2d_point_2f(&baseline_origin), glyph_run, glyph_run_desc, brush, measuring_mode);
2527
2528     d2d_device_context_draw_glyph_run(context, baseline_origin, glyph_run, glyph_run_desc, brush, measuring_mode);
2529 }
2530
2531 static void STDMETHODCALLTYPE d2d_device_context_DrawImage(ID2D1DeviceContext1 *iface, ID2D1Image *image,
2532         const D2D1_POINT_2F *target_offset, const D2D1_RECT_F *image_rect, D2D1_INTERPOLATION_MODE interpolation_mode,
2533         D2D1_COMPOSITE_MODE composite_mode)
2534 {
2535     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2536     ID2D1Bitmap *bitmap;
2537
2538     TRACE("iface %p, image %p, target_offset %s, image_rect %s, interpolation_mode %#x, composite_mode %#x.\n",
2539             iface, image, debug_d2d_point_2f(target_offset), debug_d2d_rect_f(image_rect),
2540             interpolation_mode, composite_mode);
2541
2542     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2543     {
2544         d2d_command_list_draw_image(context->target.command_list, image, target_offset, image_rect,
2545                 interpolation_mode, composite_mode);
2546         return;
2547     }
2548
2549     if (composite_mode != D2D1_COMPOSITE_MODE_SOURCE_OVER)
2550         FIXME("Unhandled composite mode %#x.\n", composite_mode);
2551
2552     if (SUCCEEDED(ID2D1Image_QueryInterface(image, &IID_ID2D1Bitmap, (void **)&bitmap)))
2553     {
2554         d2d_device_context_draw_bitmap(context, bitmap, NULL, 1.0f, interpolation_mode, image_rect, target_offset, NULL);
2555
2556         ID2D1Bitmap_Release(bitmap);
2557         return;
2558     }
2559
2560     FIXME("Unhandled image %p.\n", image);
2561 }
2562
2563 static void STDMETHODCALLTYPE d2d_device_context_DrawGdiMetafile(ID2D1DeviceContext1 *iface,
2564         ID2D1GdiMetafile *metafile, const D2D1_POINT_2F *target_offset)
2565 {
2566     FIXME("iface %p, metafile %p, target_offset %s stub!\n",
2567             iface, metafile, debug_d2d_point_2f(target_offset));
2568 }
2569
2570 static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_DrawBitmap(ID2D1DeviceContext1 *iface,
2571         ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity, D2D1_INTERPOLATION_MODE interpolation_mode,
2572         const D2D1_RECT_F *src_rect, const D2D1_MATRIX_4X4_F *perspective_transform)
2573 {
2574     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2575
2576     TRACE("iface %p, bitmap %p, dst_rect %s, opacity %.8e, interpolation_mode %#x, "
2577             "src_rect %s, perspective_transform %p.\n",
2578             iface, bitmap, debug_d2d_rect_f(dst_rect), opacity, interpolation_mode,
2579             debug_d2d_rect_f(src_rect), perspective_transform);
2580
2581     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2582     {
2583         d2d_command_list_draw_bitmap(context->target.command_list, bitmap, dst_rect, opacity, interpolation_mode,
2584                 src_rect, perspective_transform);
2585     }
2586     else
2587     {
2588         d2d_device_context_draw_bitmap(context, bitmap, dst_rect, opacity, interpolation_mode, src_rect,
2589                 NULL, perspective_transform);
2590     }
2591 }
2592
2593 static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_PushLayer(ID2D1DeviceContext1 *iface,
2594         const D2D1_LAYER_PARAMETERS1 *layer_parameters, ID2D1Layer *layer)
2595 {
2596     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2597
2598     FIXME("iface %p, layer_parameters %p, layer %p stub!\n", iface, layer_parameters, layer);
2599
2600     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2601         d2d_command_list_push_layer(context->target.command_list, context, layer_parameters, layer);
2602 }
2603
2604 static HRESULT STDMETHODCALLTYPE d2d_device_context_InvalidateEffectInputRectangle(ID2D1DeviceContext1 *iface,
2605         ID2D1Effect *effect, UINT32 input, const D2D1_RECT_F *input_rect)
2606 {
2607     FIXME("iface %p, effect %p, input %u, input_rect %s stub!\n",
2608             iface, effect, input, debug_d2d_rect_f(input_rect));
2609
2610     return E_NOTIMPL;
2611 }
2612
2613 static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectInvalidRectangleCount(ID2D1DeviceContext1 *iface,
2614         ID2D1Effect *effect, UINT32 *rect_count)
2615 {
2616     FIXME("iface %p, effect %p, rect_count %p stub!\n", iface, effect, rect_count);
2617
2618     return E_NOTIMPL;
2619 }
2620
2621 static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectInvalidRectangles(ID2D1DeviceContext1 *iface,
2622         ID2D1Effect *effect, D2D1_RECT_F *rectangles, UINT32 rect_count)
2623 {
2624     FIXME("iface %p, effect %p, rectangles %p, rect_count %u stub!\n", iface, effect, rectangles, rect_count);
2625
2626     return E_NOTIMPL;
2627 }
2628
2629 static HRESULT STDMETHODCALLTYPE d2d_device_context_GetEffectRequiredInputRectangles(ID2D1DeviceContext1 *iface,
2630         ID2D1Effect *effect, const D2D1_RECT_F *image_rect, const D2D1_EFFECT_INPUT_DESCRIPTION *desc,
2631         D2D1_RECT_F *input_rect, UINT32 input_count)
2632 {
2633     FIXME("iface %p, effect %p, image_rect %s, desc %p, input_rect %p, input_count %u stub!\n",
2634             iface, effect, debug_d2d_rect_f(image_rect), desc, input_rect, input_count);
2635
2636     return E_NOTIMPL;
2637 }
2638
2639 static void STDMETHODCALLTYPE d2d_device_context_ID2D1DeviceContext_FillOpacityMask(ID2D1DeviceContext1 *iface,
2640         ID2D1Bitmap *mask, ID2D1Brush *brush, const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect)
2641 {
2642     struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface);
2643
2644     FIXME("iface %p, mask %p, brush %p, dst_rect %s, src_rect %s stub!\n",
2645             iface, mask, brush, debug_d2d_rect_f(dst_rect), debug_d2d_rect_f(src_rect));
2646
2647     if (FAILED(context->error.code))
2648         return;
2649
2650     if (context->drawing_state.antialiasMode != D2D1_ANTIALIAS_MODE_ALIASED)
2651     {
2652         d2d_device_context_set_error(context, D2DERR_WRONG_STATE);
2653         return;
2654     }
2655
2656     if (context->target.type == D2D_TARGET_COMMAND_LIST)
2657         d2d_command_list_fill_opacity_mask(context->target.command_list, context, mask, brush, dst_rect, src_rect);
2658 }
2659
2660 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateFilledGeometryRealization(ID2D1DeviceContext1 *iface,
2661         ID2D1Geometry *geometry, float tolerance, ID2D1GeometryRealization **realization)
2662 {
2663     FIXME("iface %p, geometry %p, tolerance %.8e, realization %p stub!\n", iface, geometry, tolerance,
2664             realization);
2665
2666     return E_NOTIMPL;
2667 }
2668
2669 static HRESULT STDMETHODCALLTYPE d2d_device_context_CreateStrokedGeometryRealization(ID2D1DeviceContext1 *iface,
2670         ID2D1Geometry *geometry, float tolerance, float stroke_width, ID2D1StrokeStyle *stroke_style,
2671         ID2D1GeometryRealization **realization)
2672 {
2673     FIXME("iface %p, geometry %p, tolerance %.8e, stroke_width %.8e, stroke_style %p, realization %p stub!\n",
2674             iface, geometry, tolerance, stroke_width, stroke_style, realization);
2675
2676     return E_NOTIMPL;
2677 }
2678
2679 static void STDMETHODCALLTYPE d2d_device_context_DrawGeometryRealization(ID2D1DeviceContext1 *iface,
2680         ID2D1GeometryRealization *realization, ID2D1Brush *brush)
2681 {
2682     FIXME("iface %p, realization %p, brush %p stub!\n", iface, realization, brush);
2683 }
2684
2685 static const struct ID2D1DeviceContext1Vtbl d2d_device_context_vtbl =
2686 {
2687     d2d_device_context_QueryInterface,
2688     d2d_device_context_AddRef,
2689     d2d_device_context_Release,
2690     d2d_device_context_GetFactory,
2691     d2d_device_context_CreateBitmap,
2692     d2d_device_context_CreateBitmapFromWicBitmap,
2693     d2d_device_context_CreateSharedBitmap,
2694     d2d_device_context_CreateBitmapBrush,
2695     d2d_device_context_CreateSolidColorBrush,
2696     d2d_device_context_CreateGradientStopCollection,
2697     d2d_device_context_CreateLinearGradientBrush,
2698     d2d_device_context_CreateRadialGradientBrush,
2699     d2d_device_context_CreateCompatibleRenderTarget,
2700     d2d_device_context_CreateLayer,
2701     d2d_device_context_CreateMesh,
2702     d2d_device_context_DrawLine,
2703     d2d_device_context_DrawRectangle,
2704     d2d_device_context_FillRectangle,
2705     d2d_device_context_DrawRoundedRectangle,
2706     d2d_device_context_FillRoundedRectangle,
2707     d2d_device_context_DrawEllipse,
2708     d2d_device_context_FillEllipse,
2709     d2d_device_context_DrawGeometry,
2710     d2d_device_context_FillGeometry,
2711     d2d_device_context_FillMesh,
2712     d2d_device_context_FillOpacityMask,
2713     d2d_device_context_DrawBitmap,
2714     d2d_device_context_DrawText,
2715     d2d_device_context_DrawTextLayout,
2716     d2d_device_context_DrawGlyphRun,
2717     d2d_device_context_SetTransform,
2718     d2d_device_context_GetTransform,
2719     d2d_device_context_SetAntialiasMode,
2720     d2d_device_context_GetAntialiasMode,
2721     d2d_device_context_SetTextAntialiasMode,
2722     d2d_device_context_GetTextAntialiasMode,
2723     d2d_device_context_SetTextRenderingParams,
2724     d2d_device_context_GetTextRenderingParams,
2725     d2d_device_context_SetTags,
2726     d2d_device_context_GetTags,
2727     d2d_device_context_PushLayer,
2728     d2d_device_context_PopLayer,
2729     d2d_device_context_Flush,
2730     d2d_device_context_SaveDrawingState,
2731     d2d_device_context_RestoreDrawingState,
2732     d2d_device_context_PushAxisAlignedClip,
2733     d2d_device_context_PopAxisAlignedClip,
2734     d2d_device_context_Clear,
2735     d2d_device_context_BeginDraw,
2736     d2d_device_context_EndDraw,
2737     d2d_device_context_GetPixelFormat,
2738     d2d_device_context_SetDpi,
2739     d2d_device_context_GetDpi,
2740     d2d_device_context_GetSize,
2741     d2d_device_context_GetPixelSize,
2742     d2d_device_context_GetMaximumBitmapSize,
2743     d2d_device_context_IsSupported,
2744     d2d_device_context_ID2D1DeviceContext_CreateBitmap,
2745     d2d_device_context_ID2D1DeviceContext_CreateBitmapFromWicBitmap,
2746     d2d_device_context_CreateColorContext,
2747     d2d_device_context_CreateColorContextFromFilename,
2748     d2d_device_context_CreateColorContextFromWicColorContext,
2749     d2d_device_context_CreateBitmapFromDxgiSurface,
2750     d2d_device_context_CreateEffect,
2751     d2d_device_context_ID2D1DeviceContext_CreateGradientStopCollection,
2752     d2d_device_context_CreateImageBrush,
2753     d2d_device_context_ID2D1DeviceContext_CreateBitmapBrush,
2754     d2d_device_context_CreateCommandList,
2755     d2d_device_context_IsDxgiFormatSupported,
2756     d2d_device_context_IsBufferPrecisionSupported,
2757     d2d_device_context_GetImageLocalBounds,
2758     d2d_device_context_GetImageWorldBounds,
2759     d2d_device_context_GetGlyphRunWorldBounds,
2760     d2d_device_context_GetDevice,
2761     d2d_device_context_SetTarget,
2762     d2d_device_context_GetTarget,
2763     d2d_device_context_SetRenderingControls,
2764     d2d_device_context_GetRenderingControls,
2765     d2d_device_context_SetPrimitiveBlend,
2766     d2d_device_context_GetPrimitiveBlend,
2767     d2d_device_context_SetUnitMode,
2768     d2d_device_context_GetUnitMode,
2769     d2d_device_context_ID2D1DeviceContext_DrawGlyphRun,
2770     d2d_device_context_DrawImage,
2771     d2d_device_context_DrawGdiMetafile,
2772     d2d_device_context_ID2D1DeviceContext_DrawBitmap,
2773     d2d_device_context_ID2D1DeviceContext_PushLayer,
2774     d2d_device_context_InvalidateEffectInputRectangle,
2775     d2d_device_context_GetEffectInvalidRectangleCount,
2776     d2d_device_context_GetEffectInvalidRectangles,
2777     d2d_device_context_GetEffectRequiredInputRectangles,
2778     d2d_device_context_ID2D1DeviceContext_FillOpacityMask,
2779     d2d_device_context_CreateFilledGeometryRealization,
2780     d2d_device_context_CreateStrokedGeometryRealization,
2781     d2d_device_context_DrawGeometryRealization,
2782 };
2783
2784 static inline struct d2d_device_context *impl_from_IDWriteTextRenderer(IDWriteTextRenderer *iface)
2785 {
2786     return CONTAINING_RECORD(iface, struct d2d_device_context, IDWriteTextRenderer_iface);
2787 }
2788
2789 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_QueryInterface(IDWriteTextRenderer *iface, REFIID iid, void **out)
2790 {
2791     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
2792
2793     if (IsEqualGUID(iid, &IID_IDWriteTextRenderer)
2794             || IsEqualGUID(iid, &IID_IDWritePixelSnapping)
2795             || IsEqualGUID(iid, &IID_IUnknown))
2796     {
2797         IDWriteTextRenderer_AddRef(iface);
2798         *out = iface;
2799         return S_OK;
2800     }
2801
2802     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
2803
2804     *out = NULL;
2805     return E_NOINTERFACE;
2806 }
2807
2808 static ULONG STDMETHODCALLTYPE d2d_text_renderer_AddRef(IDWriteTextRenderer *iface)
2809 {
2810     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2811
2812     TRACE("iface %p.\n", iface);
2813
2814     return d2d_device_context_AddRef(&render_target->ID2D1DeviceContext1_iface);
2815 }
2816
2817 static ULONG STDMETHODCALLTYPE d2d_text_renderer_Release(IDWriteTextRenderer *iface)
2818 {
2819     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2820
2821     TRACE("iface %p.\n", iface);
2822
2823     return d2d_device_context_Release(&render_target->ID2D1DeviceContext1_iface);
2824 }
2825
2826 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_IsPixelSnappingDisabled(IDWriteTextRenderer *iface,
2827         void *ctx, BOOL *disabled)
2828 {
2829     struct d2d_draw_text_layout_ctx *context = ctx;
2830
2831     TRACE("iface %p, ctx %p, disabled %p.\n", iface, ctx, disabled);
2832
2833     *disabled = context->options & D2D1_DRAW_TEXT_OPTIONS_NO_SNAP;
2834
2835     return S_OK;
2836 }
2837
2838 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_GetCurrentTransform(IDWriteTextRenderer *iface,
2839         void *ctx, DWRITE_MATRIX *transform)
2840 {
2841     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2842
2843     TRACE("iface %p, ctx %p, transform %p.\n", iface, ctx, transform);
2844
2845     d2d_device_context_GetTransform(&render_target->ID2D1DeviceContext1_iface, (D2D1_MATRIX_3X2_F *)transform);
2846
2847     return S_OK;
2848 }
2849
2850 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_GetPixelsPerDip(IDWriteTextRenderer *iface, void *ctx, float *ppd)
2851 {
2852     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2853
2854     TRACE("iface %p, ctx %p, ppd %p.\n", iface, ctx, ppd);
2855
2856     *ppd = render_target->desc.dpiY / 96.0f;
2857
2858     return S_OK;
2859 }
2860
2861 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawGlyphRun(IDWriteTextRenderer *iface, void *ctx,
2862         float baseline_origin_x, float baseline_origin_y, DWRITE_MEASURING_MODE measuring_mode,
2863         const DWRITE_GLYPH_RUN *glyph_run, const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, IUnknown *effect)
2864 {
2865     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2866     D2D1_POINT_2F baseline_origin = {baseline_origin_x, baseline_origin_y};
2867     struct d2d_draw_text_layout_ctx *context = ctx;
2868     BOOL color_font = FALSE;
2869     ID2D1Brush *brush;
2870
2871     TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, "
2872             "measuring_mode %#x, glyph_run %p, glyph_run_desc %p, effect %p.\n",
2873             iface, ctx, baseline_origin_x, baseline_origin_y,
2874             measuring_mode, glyph_run, glyph_run_desc, effect);
2875
2876     if (context->options & ~(D2D1_DRAW_TEXT_OPTIONS_NO_SNAP | D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT))
2877         FIXME("Ignoring options %#x.\n", context->options);
2878
2879     brush = d2d_draw_get_text_brush(context, effect);
2880
2881     TRACE("%s\n", debugstr_wn(glyph_run_desc->string, glyph_run_desc->stringLength));
2882
2883     if (context->options & D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT)
2884     {
2885         IDWriteFontFace2 *fontface;
2886
2887         if (SUCCEEDED(IDWriteFontFace_QueryInterface(glyph_run->fontFace,
2888                 &IID_IDWriteFontFace2, (void **)&fontface)))
2889         {
2890             color_font = IDWriteFontFace2_IsColorFont(fontface);
2891             IDWriteFontFace2_Release(fontface);
2892         }
2893     }
2894
2895     if (color_font)
2896     {
2897         IDWriteColorGlyphRunEnumerator *layers;
2898         IDWriteFactory2 *dwrite_factory;
2899         HRESULT hr;
2900
2901         if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory2,
2902                 (IUnknown **)&dwrite_factory)))
2903         {
2904             ERR("Failed to create dwrite factory, hr %#lx.\n", hr);
2905             ID2D1Brush_Release(brush);
2906             return hr;
2907         }
2908
2909         hr = IDWriteFactory2_TranslateColorGlyphRun(dwrite_factory, baseline_origin_x, baseline_origin_y,
2910                 glyph_run, glyph_run_desc, measuring_mode, (DWRITE_MATRIX *)&render_target->drawing_state.transform, 0, &layers);
2911         IDWriteFactory2_Release(dwrite_factory);
2912         if (FAILED(hr))
2913         {
2914             ERR("Failed to create colour glyph run enumerator, hr %#lx.\n", hr);
2915             ID2D1Brush_Release(brush);
2916             return hr;
2917         }
2918
2919         for (;;)
2920         {
2921             const DWRITE_COLOR_GLYPH_RUN *color_run;
2922             ID2D1Brush *color_brush;
2923             D2D1_POINT_2F origin;
2924             BOOL has_run = FALSE;
2925
2926             if (FAILED(hr = IDWriteColorGlyphRunEnumerator_MoveNext(layers, &has_run)))
2927             {
2928                 ERR("Failed to switch colour glyph layer, hr %#lx.\n", hr);
2929                 break;
2930             }
2931
2932             if (!has_run)
2933                 break;
2934
2935             if (FAILED(hr = IDWriteColorGlyphRunEnumerator_GetCurrentRun(layers, &color_run)))
2936             {
2937                 ERR("Failed to get current colour run, hr %#lx.\n", hr);
2938                 break;
2939             }
2940
2941             if (color_run->paletteIndex == 0xffff)
2942                 color_brush = brush;
2943             else
2944             {
2945                 if (FAILED(hr = d2d_device_context_CreateSolidColorBrush(&render_target->ID2D1DeviceContext1_iface,
2946                         &color_run->runColor, NULL, (ID2D1SolidColorBrush **)&color_brush)))
2947                 {
2948                     ERR("Failed to create solid colour brush, hr %#lx.\n", hr);
2949                     break;
2950                 }
2951             }
2952
2953             origin.x = color_run->baselineOriginX;
2954             origin.y = color_run->baselineOriginY;
2955             d2d_device_context_draw_glyph_run(render_target, origin, &color_run->glyphRun,
2956                     color_run->glyphRunDescription, color_brush, measuring_mode);
2957
2958             if (color_brush != brush)
2959                 ID2D1Brush_Release(color_brush);
2960         }
2961
2962         IDWriteColorGlyphRunEnumerator_Release(layers);
2963     }
2964     else
2965         d2d_device_context_draw_glyph_run(render_target, baseline_origin, glyph_run, glyph_run_desc,
2966                 brush, measuring_mode);
2967
2968     ID2D1Brush_Release(brush);
2969
2970     return S_OK;
2971 }
2972
2973 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawUnderline(IDWriteTextRenderer *iface, void *ctx,
2974         float baseline_origin_x, float baseline_origin_y, const DWRITE_UNDERLINE *underline, IUnknown *effect)
2975 {
2976     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
2977     const D2D1_MATRIX_3X2_F *m = &render_target->drawing_state.transform;
2978     struct d2d_draw_text_layout_ctx *context = ctx;
2979     D2D1_ANTIALIAS_MODE prev_antialias_mode;
2980     D2D1_POINT_2F start, end;
2981     ID2D1Brush *brush;
2982     float thickness;
2983
2984     TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, underline %p, effect %p\n",
2985             iface, ctx, baseline_origin_x, baseline_origin_y, underline, effect);
2986
2987     /* minimal thickness in DIPs that will result in at least 1 pixel thick line */
2988     thickness = max(96.0f / (render_target->desc.dpiY * sqrtf(m->_21 * m->_21 + m->_22 * m->_22)),
2989             underline->thickness);
2990
2991     brush = d2d_draw_get_text_brush(context, effect);
2992
2993     start.x = baseline_origin_x;
2994     start.y = baseline_origin_y + underline->offset + thickness / 2.0f;
2995     end.x = start.x + underline->width;
2996     end.y = start.y;
2997     prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target);
2998     d2d_device_context_DrawLine(&render_target->ID2D1DeviceContext1_iface, start, end, brush, thickness, NULL);
2999     render_target->drawing_state.antialiasMode = prev_antialias_mode;
3000
3001     ID2D1Brush_Release(brush);
3002
3003     return S_OK;
3004 }
3005
3006 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawStrikethrough(IDWriteTextRenderer *iface, void *ctx,
3007         float baseline_origin_x, float baseline_origin_y, const DWRITE_STRIKETHROUGH *strikethrough, IUnknown *effect)
3008 {
3009     struct d2d_device_context *render_target = impl_from_IDWriteTextRenderer(iface);
3010     const D2D1_MATRIX_3X2_F *m = &render_target->drawing_state.transform;
3011     struct d2d_draw_text_layout_ctx *context = ctx;
3012     D2D1_ANTIALIAS_MODE prev_antialias_mode;
3013     D2D1_POINT_2F start, end;
3014     ID2D1Brush *brush;
3015     float thickness;
3016
3017     TRACE("iface %p, ctx %p, baseline_origin_x %.8e, baseline_origin_y %.8e, strikethrough %p, effect %p.\n",
3018             iface, ctx, baseline_origin_x, baseline_origin_y, strikethrough, effect);
3019
3020     /* minimal thickness in DIPs that will result in at least 1 pixel thick line */
3021     thickness = max(96.0f / (render_target->desc.dpiY * sqrtf(m->_21 * m->_21 + m->_22 * m->_22)),
3022             strikethrough->thickness);
3023
3024     brush = d2d_draw_get_text_brush(context, effect);
3025
3026     start.x = baseline_origin_x;
3027     start.y = baseline_origin_y + strikethrough->offset + thickness / 2.0f;
3028     end.x = start.x + strikethrough->width;
3029     end.y = start.y;
3030     prev_antialias_mode = d2d_device_context_set_aa_mode_from_text_aa_mode(render_target);
3031     d2d_device_context_DrawLine(&render_target->ID2D1DeviceContext1_iface, start, end, brush, thickness, NULL);
3032     render_target->drawing_state.antialiasMode = prev_antialias_mode;
3033
3034     ID2D1Brush_Release(brush);
3035
3036     return S_OK;
3037 }
3038
3039 static HRESULT STDMETHODCALLTYPE d2d_text_renderer_DrawInlineObject(IDWriteTextRenderer *iface, void *ctx,
3040         float origin_x, float origin_y, IDWriteInlineObject *object, BOOL is_sideways, BOOL is_rtl, IUnknown *effect)
3041 {
3042     struct d2d_draw_text_layout_ctx *context = ctx;
3043     ID2D1Brush *brush;
3044     HRESULT hr;
3045
3046     TRACE("iface %p, ctx %p, origin_x %.8e, origin_y %.8e, object %p, is_sideways %#x, is_rtl %#x, effect %p.\n",
3047             iface, ctx, origin_x, origin_y, object, is_sideways, is_rtl, effect);
3048
3049     /* Inline objects may not pass effects all the way down, when using layout object internally for example.
3050        This is how default trimming sign object in DirectWrite works - it does not use effect passed to Draw(),
3051        and resulting DrawGlyphRun() is always called with NULL effect, however original effect is used and correct
3052        brush is selected at Direct2D level. */
3053     brush = context->brush;
3054     context->brush = d2d_draw_get_text_brush(context, effect);
3055
3056     hr = IDWriteInlineObject_Draw(object, ctx, iface, origin_x, origin_y, is_sideways, is_rtl, effect);
3057
3058     ID2D1Brush_Release(context->brush);
3059     context->brush = brush;
3060
3061     return hr;
3062 }
3063
3064 static const struct IDWriteTextRendererVtbl d2d_text_renderer_vtbl =
3065 {
3066     d2d_text_renderer_QueryInterface,
3067     d2d_text_renderer_AddRef,
3068     d2d_text_renderer_Release,
3069     d2d_text_renderer_IsPixelSnappingDisabled,
3070     d2d_text_renderer_GetCurrentTransform,
3071     d2d_text_renderer_GetPixelsPerDip,
3072     d2d_text_renderer_DrawGlyphRun,
3073     d2d_text_renderer_DrawUnderline,
3074     d2d_text_renderer_DrawStrikethrough,
3075     d2d_text_renderer_DrawInlineObject,
3076 };
3077
3078 static inline struct d2d_device_context *impl_from_ID2D1GdiInteropRenderTarget(ID2D1GdiInteropRenderTarget *iface)
3079 {
3080     return CONTAINING_RECORD(iface, struct d2d_device_context, ID2D1GdiInteropRenderTarget_iface);
3081 }
3082
3083 static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_QueryInterface(ID2D1GdiInteropRenderTarget *iface,
3084         REFIID iid, void **out)
3085 {
3086     struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface);
3087
3088     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
3089
3090     return IUnknown_QueryInterface(render_target->outer_unknown, iid, out);
3091 }
3092
3093 static ULONG STDMETHODCALLTYPE d2d_gdi_interop_render_target_AddRef(ID2D1GdiInteropRenderTarget *iface)
3094 {
3095     struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface);
3096
3097     TRACE("iface %p.\n", iface);
3098
3099     return IUnknown_AddRef(render_target->outer_unknown);
3100 }
3101
3102 static ULONG STDMETHODCALLTYPE d2d_gdi_interop_render_target_Release(ID2D1GdiInteropRenderTarget *iface)
3103 {
3104     struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface);
3105
3106     TRACE("iface %p.\n", iface);
3107
3108     return IUnknown_Release(render_target->outer_unknown);
3109 }
3110
3111 static HRESULT d2d_gdi_interop_get_surface(struct d2d_device_context *context, IDXGISurface1 **surface)
3112 {
3113     ID3D11Resource *resource;
3114     HRESULT hr;
3115
3116     if (context->target.type != D2D_TARGET_BITMAP)
3117     {
3118         FIXME("Unimplemented for target type %u.\n", context->target.type);
3119         return E_NOTIMPL;
3120     }
3121
3122     if (!(context->target.bitmap->options & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE))
3123         return D2DERR_TARGET_NOT_GDI_COMPATIBLE;
3124
3125     ID3D11RenderTargetView_GetResource(context->target.bitmap->rtv, &resource);
3126     hr = ID3D11Resource_QueryInterface(resource, &IID_IDXGISurface1, (void **)surface);
3127     ID3D11Resource_Release(resource);
3128     if (FAILED(hr))
3129     {
3130         *surface = NULL;
3131         WARN("Failed to get DXGI surface, %#lx.\n", hr);
3132         return hr;
3133     }
3134
3135     return hr;
3136 }
3137
3138 static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_GetDC(ID2D1GdiInteropRenderTarget *iface,
3139         D2D1_DC_INITIALIZE_MODE mode, HDC *dc)
3140 {
3141     struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface);
3142     IDXGISurface1 *surface;
3143     HRESULT hr;
3144
3145     TRACE("iface %p, mode %d, dc %p.\n", iface, mode, dc);
3146
3147     *dc = NULL;
3148
3149     if (render_target->target.hdc)
3150         return D2DERR_WRONG_STATE;
3151
3152     if (FAILED(hr = d2d_gdi_interop_get_surface(render_target, &surface)))
3153         return hr;
3154
3155     hr = IDXGISurface1_GetDC(surface, mode != D2D1_DC_INITIALIZE_MODE_COPY, &render_target->target.hdc);
3156     IDXGISurface1_Release(surface);
3157
3158     if (SUCCEEDED(hr))
3159         *dc = render_target->target.hdc;
3160
3161     return hr;
3162 }
3163
3164 static HRESULT STDMETHODCALLTYPE d2d_gdi_interop_render_target_ReleaseDC(ID2D1GdiInteropRenderTarget *iface,
3165         const RECT *update)
3166 {
3167     struct d2d_device_context *render_target = impl_from_ID2D1GdiInteropRenderTarget(iface);
3168     IDXGISurface1 *surface;
3169     RECT update_rect;
3170     HRESULT hr;
3171
3172     TRACE("iface %p, update rect %s.\n", iface, wine_dbgstr_rect(update));
3173
3174     if (!render_target->target.hdc)
3175         return D2DERR_WRONG_STATE;
3176
3177     if (FAILED(hr = d2d_gdi_interop_get_surface(render_target, &surface)))
3178         return hr;
3179
3180     render_target->target.hdc = NULL;
3181     if (update)
3182         update_rect = *update;
3183     hr = IDXGISurface1_ReleaseDC(surface, update ? &update_rect : NULL);
3184     IDXGISurface1_Release(surface);
3185
3186     return hr;
3187 }
3188
3189 static const struct ID2D1GdiInteropRenderTargetVtbl d2d_gdi_interop_render_target_vtbl =
3190 {
3191     d2d_gdi_interop_render_target_QueryInterface,
3192     d2d_gdi_interop_render_target_AddRef,
3193     d2d_gdi_interop_render_target_Release,
3194     d2d_gdi_interop_render_target_GetDC,
3195     d2d_gdi_interop_render_target_ReleaseDC,
3196 };
3197
3198 static HRESULT d2d_device_context_init(struct d2d_device_context *render_target,
3199         struct d2d_device *device, IUnknown *outer_unknown, const struct d2d_device_context_ops *ops)
3200 {
3201     D3D11_SUBRESOURCE_DATA buffer_data;
3202     struct d2d_device *device_impl;
3203     IDWriteFactory *dwrite_factory;
3204     D3D11_RASTERIZER_DESC rs_desc;
3205     D3D11_BUFFER_DESC buffer_desc;
3206     struct d2d_factory *factory;
3207     ID3D10Blob *compiled;
3208     unsigned int i;
3209     HRESULT hr;
3210
3211     static const D3D11_INPUT_ELEMENT_DESC il_desc_outline[] =
3212     {
3213         {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
3214         {"PREV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0},
3215         {"NEXT", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0},
3216     };
3217     static const D3D11_INPUT_ELEMENT_DESC il_desc_curve_outline[] =
3218     {
3219         {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
3220         {"P", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0},
3221         {"P", 1, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0},
3222         {"P", 2, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0},
3223         {"PREV", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0},
3224         {"NEXT", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 40, D3D11_INPUT_PER_VERTEX_DATA, 0},
3225     };
3226     static const D3D11_INPUT_ELEMENT_DESC il_desc_triangle[] =
3227     {
3228         {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
3229     };
3230     static const D3D11_INPUT_ELEMENT_DESC il_desc_curve[] =
3231     {
3232         {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
3233         {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0},
3234     };
3235     static const char vs_code_outline[] =
3236         "float3x2 transform_geometry;\n"
3237         "float stroke_width;\n"
3238         "float4 transform_rtx;\n"
3239         "float4 transform_rty;\n"
3240         "\n"
3241         "struct output\n"
3242         "{\n"
3243         "    float2 p : WORLD_POSITION;\n"
3244         "    float4 b : BEZIER;\n"
3245         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3246         "    float4 position : SV_POSITION;\n"
3247         "};\n"
3248         "\n"
3249         "/* The lines PₚᵣₑᵥP₀ and P₀Pₙₑₓₜ, both offset by ±½w, intersect each other at:\n"
3250         " *\n"
3251         " *   Pᵢ = P₀ ± w · ½q⃑ᵢ.\n"
3252         " *\n"
3253         " * Where:\n"
3254         " *\n"
3255         " *   q⃑ᵢ = q̂ₚᵣₑᵥ⊥ + tan(½θ) · -q̂ₚᵣₑᵥ\n"
3256         " *   θ  = ∠PₚᵣₑᵥP₀Pₙₑₓₜ\n"
3257         " *   q⃑ₚᵣₑᵥ = P₀ - Pₚᵣₑᵥ */\n"
3258         "void main(float2 position : POSITION, float2 prev : PREV, float2 next : NEXT, out struct output o)\n"
3259         "{\n"
3260         "    float2 q_prev, q_next, v_p, q_i;\n"
3261         "    float2x2 geom;\n"
3262         "    float l;\n"
3263         "\n"
3264         "    o.stroke_transform = float2x2(transform_rtx.xy, transform_rty.xy) * stroke_width * 0.5f;\n"
3265         "\n"
3266         "    geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n"
3267         "    q_prev = normalize(mul(geom, prev));\n"
3268         "    q_next = normalize(mul(geom, next));\n"
3269         "\n"
3270         "    /* tan(½θ) = sin(θ) / (1 + cos(θ))\n"
3271         "     *         = (q̂ₚᵣₑᵥ⊥ · q̂ₙₑₓₜ) / (1 + (q̂ₚᵣₑᵥ · q̂ₙₑₓₜ)) */\n"
3272         "    v_p = float2(-q_prev.y, q_prev.x);\n"
3273         "    l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n"
3274         "    q_i = l * q_prev + v_p;\n"
3275         "\n"
3276         "    o.b = float4(0.0, 0.0, 0.0, 0.0);\n"
3277         "\n"
3278         "    o.p = mul(float3(position, 1.0f), transform_geometry) + stroke_width * 0.5f * q_i;\n"
3279         "    position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n"
3280         "            * float2(transform_rtx.w, transform_rty.w);\n"
3281         "    o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n"
3282         "}\n";
3283     /*     ⎡p0.x p0.y 1⎤
3284      * A = ⎢p1.x p1.y 1⎥
3285      *     ⎣p2.x p2.y 1⎦
3286      *
3287      *     ⎡0 0⎤
3288      * B = ⎢½ 0⎥
3289      *     ⎣1 1⎦
3290      *
3291      * A' = ⎡p1.x-p0.x p1.y-p0.y⎤
3292      *      ⎣p2.x-p0.x p2.y-p0.y⎦
3293      *
3294      * B' = ⎡½ 0⎤
3295      *      ⎣1 1⎦
3296      *
3297      * A'T = B'
3298      * T = A'⁻¹B'
3299      */
3300     static const char vs_code_bezier_outline[] =
3301         "float3x2 transform_geometry;\n"
3302         "float stroke_width;\n"
3303         "float4 transform_rtx;\n"
3304         "float4 transform_rty;\n"
3305         "\n"
3306         "struct output\n"
3307         "{\n"
3308         "    float2 p : WORLD_POSITION;\n"
3309         "    float4 b : BEZIER;\n"
3310         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3311         "    float4 position : SV_POSITION;\n"
3312         "};\n"
3313         "\n"
3314         "void main(float2 position : POSITION, float2 p0 : P0, float2 p1 : P1, float2 p2 : P2,\n"
3315         "        float2 prev : PREV, float2 next : NEXT, out struct output o)\n"
3316         "{\n"
3317         "    float2 q_prev, q_next, v_p, q_i, p;\n"
3318         "    float2x2 geom, rt;\n"
3319         "    float l;\n"
3320         "\n"
3321         "    geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n"
3322         "    rt = float2x2(transform_rtx.xy, transform_rty.xy);\n"
3323         "    o.stroke_transform = rt * stroke_width * 0.5f;\n"
3324         "\n"
3325         "    p = mul(geom, position);\n"
3326         "    p0 = mul(geom, p0);\n"
3327         "    p1 = mul(geom, p1);\n"
3328         "    p2 = mul(geom, p2);\n"
3329         "\n"
3330         "    p -= p0;\n"
3331         "    p1 -= p0;\n"
3332         "    p2 -= p0;\n"
3333         "\n"
3334         "    q_prev = normalize(mul(geom, prev));\n"
3335         "    q_next = normalize(mul(geom, next));\n"
3336         "\n"
3337         "    v_p = float2(-q_prev.y, q_prev.x);\n"
3338         "    l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n"
3339         "    q_i = l * q_prev + v_p;\n"
3340         "    p += 0.5f * stroke_width * q_i;\n"
3341         "\n"
3342         "    v_p = mul(rt, p2);\n"
3343         "    v_p = normalize(float2(-v_p.y, v_p.x));\n"
3344         "    if (abs(dot(mul(rt, p1), v_p)) < 1.0f)\n"
3345         "    {\n"
3346         "        o.b.xzw = float3(0.0f, 0.0f, 0.0f);\n"
3347         "        o.b.y = dot(mul(rt, p), v_p);\n"
3348         "    }\n"
3349         "    else\n"
3350         "    {\n"
3351         "        o.b.zw = sign(dot(mul(rt, p1), v_p)) * v_p;\n"
3352         "        v_p = -float2(-p.y, p.x) / dot(float2(-p1.y, p1.x), p2);\n"
3353         "        o.b.x = dot(v_p, p1 - 0.5f * p2);\n"
3354         "        o.b.y = dot(v_p, p1);\n"
3355         "    }\n"
3356         "\n"
3357         "    o.p = mul(float3(position, 1.0f), transform_geometry) + 0.5f * stroke_width * q_i;\n"
3358         "    position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n"
3359         "            * float2(transform_rtx.w, transform_rty.w);\n"
3360         "    o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n"
3361         "}\n";
3362     /*     ⎡p0.x p0.y 1⎤
3363      * A = ⎢p1.x p1.y 1⎥
3364      *     ⎣p2.x p2.y 1⎦
3365      *
3366      *     ⎡1 0⎤
3367      * B = ⎢1 1⎥
3368      *     ⎣0 1⎦
3369      *
3370      * A' = ⎡p1.x-p0.x p1.y-p0.y⎤
3371      *      ⎣p2.x-p0.x p2.y-p0.y⎦
3372      *
3373      * B' = ⎡ 0 1⎤
3374      *      ⎣-1 1⎦
3375      *
3376      * A'T = B'
3377      * T = A'⁻¹B' = (B'⁻¹A')⁻¹
3378      */
3379     static const char vs_code_arc_outline[] =
3380         "float3x2 transform_geometry;\n"
3381         "float stroke_width;\n"
3382         "float4 transform_rtx;\n"
3383         "float4 transform_rty;\n"
3384         "\n"
3385         "struct output\n"
3386         "{\n"
3387         "    float2 p : WORLD_POSITION;\n"
3388         "    float4 b : BEZIER;\n"
3389         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3390         "    float4 position : SV_POSITION;\n"
3391         "};\n"
3392         "\n"
3393         "void main(float2 position : POSITION, float2 p0 : P0, float2 p1 : P1, float2 p2 : P2,\n"
3394         "        float2 prev : PREV, float2 next : NEXT, out struct output o)\n"
3395         "{\n"
3396         "    float2 q_prev, q_next, v_p, q_i, p;\n"
3397         "    float2x2 geom, rt, p_inv;\n"
3398         "    float l;\n"
3399         "    float a;\n"
3400         "    float2 bc;\n"
3401         "\n"
3402         "    geom = float2x2(transform_geometry._11_21, transform_geometry._12_22);\n"
3403         "    rt = float2x2(transform_rtx.xy, transform_rty.xy);\n"
3404         "    o.stroke_transform = rt * stroke_width * 0.5f;\n"
3405         "\n"
3406         "    p = mul(geom, position);\n"
3407         "    p0 = mul(geom, p0);\n"
3408         "    p1 = mul(geom, p1);\n"
3409         "    p2 = mul(geom, p2);\n"
3410         "\n"
3411         "    p -= p0;\n"
3412         "    p1 -= p0;\n"
3413         "    p2 -= p0;\n"
3414         "\n"
3415         "    q_prev = normalize(mul(geom, prev));\n"
3416         "    q_next = normalize(mul(geom, next));\n"
3417         "\n"
3418         "    v_p = float2(-q_prev.y, q_prev.x);\n"
3419         "    l = -dot(v_p, q_next) / (1.0f + dot(q_prev, q_next));\n"
3420         "    q_i = l * q_prev + v_p;\n"
3421         "    p += 0.5f * stroke_width * q_i;\n"
3422         "\n"
3423         "    p_inv = float2x2(p1.y, -p1.x, p2.y - p1.y, p1.x - p2.x) / (p1.x * p2.y - p2.x * p1.y);\n"
3424         "    o.b.xy = mul(p_inv, p) + float2(1.0f, 0.0f);\n"
3425         "    o.b.zw = 0.0f;\n"
3426         "\n"
3427         "    o.p = mul(float3(position, 1.0f), transform_geometry) + 0.5f * stroke_width * q_i;\n"
3428         "    position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n"
3429         "            * float2(transform_rtx.w, transform_rty.w);\n"
3430         "    o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n"
3431         "}\n";
3432     static const char vs_code_triangle[] =
3433         "float3x2 transform_geometry;\n"
3434         "float4 transform_rtx;\n"
3435         "float4 transform_rty;\n"
3436         "\n"
3437         "struct output\n"
3438         "{\n"
3439         "    float2 p : WORLD_POSITION;\n"
3440         "    float4 b : BEZIER;\n"
3441         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3442         "    float4 position : SV_POSITION;\n"
3443         "};\n"
3444         "\n"
3445         "void main(float2 position : POSITION, out struct output o)\n"
3446         "{\n"
3447         "    o.p = mul(float3(position, 1.0f), transform_geometry);\n"
3448         "    o.b = float4(1.0, 0.0, 1.0, 1.0);\n"
3449         "    o.stroke_transform = float2x2(1.0, 0.0, 0.0, 1.0);\n"
3450         "    position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n"
3451         "            * float2(transform_rtx.w, transform_rty.w);\n"
3452         "    o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n"
3453         "}\n";
3454     static const char vs_code_curve[] =
3455         "float3x2 transform_geometry;\n"
3456         "float4 transform_rtx;\n"
3457         "float4 transform_rty;\n"
3458         "\n"
3459         "struct output\n"
3460         "{\n"
3461         "    float2 p : WORLD_POSITION;\n"
3462         "    float4 b : BEZIER;\n"
3463         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3464         "    float4 position : SV_POSITION;\n"
3465         "};\n"
3466         "\n"
3467         "void main(float2 position : POSITION, float3 texcoord : TEXCOORD0, out struct output o)\n"
3468         "{\n"
3469         "    o.p = mul(float3(position, 1.0f), transform_geometry);\n"
3470         "    o.b = float4(texcoord, 1.0);\n"
3471         "    o.stroke_transform = float2x2(1.0, 0.0, 0.0, 1.0);\n"
3472         "    position = mul(float2x3(transform_rtx.xyz, transform_rty.xyz), float3(o.p, 1.0f))\n"
3473         "            * float2(transform_rtx.w, transform_rty.w);\n"
3474         "    o.position = float4(position + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n"
3475         "}\n";
3476     static const char ps_code[] =
3477         "#define BRUSH_TYPE_SOLID    0\n"
3478         "#define BRUSH_TYPE_LINEAR   1\n"
3479         "#define BRUSH_TYPE_RADIAL   2\n"
3480         "#define BRUSH_TYPE_BITMAP   3\n"
3481         "#define BRUSH_TYPE_COUNT    4\n"
3482         "\n"
3483         "bool outline;\n"
3484         "bool is_arc;\n"
3485         "struct brush\n"
3486         "{\n"
3487         "    uint type;\n"
3488         "    float opacity;\n"
3489         "    float4 data[3];\n"
3490         "} colour_brush, opacity_brush;\n"
3491         "\n"
3492         "SamplerState s0, s1;\n"
3493         "Texture2D t0, t1;\n"
3494         "Buffer<float4> b0, b1;\n"
3495         "\n"
3496         "struct input\n"
3497         "{\n"
3498         "    float2 p : WORLD_POSITION;\n"
3499         "    float4 b : BEZIER;\n"
3500         "    nointerpolation float2x2 stroke_transform : STROKE_TRANSFORM;\n"
3501         "};\n"
3502         "\n"
3503         "float4 sample_gradient(Buffer<float4> gradient, uint stop_count, float position)\n"
3504         "{\n"
3505         "    float4 c_low, c_high;\n"
3506         "    float p_low, p_high;\n"
3507         "    uint i;\n"
3508         "\n"
3509         "    p_low = gradient.Load(0).x;\n"
3510         "    c_low = gradient.Load(1);\n"
3511         "    c_high = c_low;\n"
3512         "\n"
3513         "    if (position < p_low)\n"
3514         "        return c_low;\n"
3515         "\n"
3516         "    for (i = 1; i < stop_count; ++i)\n"
3517         "    {\n"
3518         "        p_high = gradient.Load(i * 2).x;\n"
3519         "        c_high = gradient.Load(i * 2 + 1);\n"
3520         "\n"
3521         "        if (position >= p_low && position <= p_high)\n"
3522         "            return lerp(c_low, c_high, (position - p_low) / (p_high - p_low));\n"
3523         "\n"
3524         "        p_low = p_high;\n"
3525         "        c_low = c_high;\n"
3526         "    }\n"
3527         "\n"
3528         "    return c_high;\n"
3529         "}\n"
3530         "\n"
3531         "float4 brush_linear(struct brush brush, Buffer<float4> gradient, float2 position)\n"
3532         "{\n"
3533         "    float2 start, end, v_p, v_q;\n"
3534         "    uint stop_count;\n"
3535         "    float p;\n"
3536         "\n"
3537         "    start = brush.data[0].xy;\n"
3538         "    end = brush.data[0].zw;\n"
3539         "    stop_count = asuint(brush.data[1].x);\n"
3540         "\n"
3541         "    v_p = position - start;\n"
3542         "    v_q = end - start;\n"
3543         "    p = dot(v_q, v_p) / dot(v_q, v_q);\n"
3544         "\n"
3545         "    return sample_gradient(gradient, stop_count, p);\n"
3546         "}\n"
3547         "\n"
3548         "float4 brush_radial(struct brush brush, Buffer<float4> gradient, float2 position)\n"
3549         "{\n"
3550         "    float2 centre, offset, ra, rb, v_p, v_q, r;\n"
3551         "    float b, c, l, t;\n"
3552         "    uint stop_count;\n"
3553         "\n"
3554         "    centre = brush.data[0].xy;\n"
3555         "    offset = brush.data[0].zw;\n"
3556         "    ra = brush.data[1].xy;\n"
3557         "    rb = brush.data[1].zw;\n"
3558         "    stop_count = asuint(brush.data[2].x);\n"
3559         "\n"
3560         "    /* Project onto ra, rb. */\n"
3561         "    r = float2(dot(ra, ra), dot(rb, rb));\n"
3562         "    v_p = position - (centre + offset);\n"
3563         "    v_p = float2(dot(v_p, ra), dot(v_p, rb)) / r;\n"
3564         "    v_q = float2(dot(offset, ra), dot(offset, rb)) / r;\n"
3565         "\n"
3566         "    /* ‖t·p̂ + q⃑‖ = 1\n"
3567         "     * (t·p̂ + q⃑) · (t·p̂ + q⃑) = 1\n"
3568         "     * t² + 2·(p̂·q⃑)·t + (q⃑·q⃑) = 1\n"
3569         "     *\n"
3570         "     * b = p̂·q⃑\n"
3571         "     * c = q⃑·q⃑ - 1\n"
3572         "     * t = -b + √(b² - c) */\n"
3573         "    l = length(v_p);\n"
3574         "    b = dot(v_p, v_q) / l;\n"
3575         "    c = dot(v_q, v_q) - 1.0;\n"
3576         "    t = -b + sqrt(b * b - c);\n"
3577         "\n"
3578         "    return sample_gradient(gradient, stop_count, l / t);\n"
3579         "}\n"
3580         "\n"
3581         "float4 brush_bitmap(struct brush brush, Texture2D t, SamplerState s, float2 position)\n"
3582         "{\n"
3583         "    float3 transform[2];\n"
3584         "    bool ignore_alpha;\n"
3585         "    float2 texcoord;\n"
3586         "    float4 colour;\n"
3587         "\n"
3588         "    transform[0] = brush.data[0].xyz;\n"
3589         "    transform[1] = brush.data[1].xyz;\n"
3590         "    ignore_alpha = asuint(brush.data[1].w);\n"
3591         "\n"
3592         "    texcoord.x = dot(position.xy, transform[0].xy) + transform[0].z;\n"
3593         "    texcoord.y = dot(position.xy, transform[1].xy) + transform[1].z;\n"
3594         "    colour = t.Sample(s, texcoord);\n"
3595         "    if (ignore_alpha)\n"
3596         "        colour.a = 1.0;\n"
3597         "    return colour;\n"
3598         "}\n"
3599         "\n"
3600         "float4 sample_brush(struct brush brush, Texture2D t, SamplerState s, Buffer<float4> b, float2 position)\n"
3601         "{\n"
3602         "    if (brush.type == BRUSH_TYPE_SOLID)\n"
3603         "        return brush.data[0] * brush.opacity;\n"
3604         "    if (brush.type == BRUSH_TYPE_LINEAR)\n"
3605         "        return brush_linear(brush, b, position) * brush.opacity;\n"
3606         "    if (brush.type == BRUSH_TYPE_RADIAL)\n"
3607         "        return brush_radial(brush, b, position) * brush.opacity;\n"
3608         "    if (brush.type == BRUSH_TYPE_BITMAP)\n"
3609         "        return brush_bitmap(brush, t, s, position) * brush.opacity;\n"
3610         "    return float4(0.0, 0.0, 0.0, brush.opacity);\n"
3611         "}\n"
3612         "\n"
3613         "float4 main(struct input i) : SV_Target\n"
3614         "{\n"
3615         "    float4 colour;\n"
3616         "\n"
3617         "    colour = sample_brush(colour_brush, t0, s0, b0, i.p);\n"
3618         "    if (opacity_brush.type < BRUSH_TYPE_COUNT)\n"
3619         "        colour *= sample_brush(opacity_brush, t1, s1, b1, i.p).a;\n"
3620         "\n"
3621         "    if (outline)\n"
3622         "    {\n"
3623         "        float2 du, dv, df;\n"
3624         "        float4 uv;\n"
3625         "\n"
3626         "        /* Evaluate the implicit form of the curve (u² - v = 0\n"
3627         "         * for Béziers, u² + v² - 1 = 0 for arcs) in texture\n"
3628         "         * space, using the screen-space partial derivatives\n"
3629         "         * to convert the calculated distance to object space.\n"
3630         "         *\n"
3631         "         * d(x, y) = |f(x, y)| / ‖∇f(x, y)‖\n"
3632         "         *         = |f(x, y)| / √((∂f/∂x)² + (∂f/∂y)²)\n"
3633         "         *\n"
3634         "         * For Béziers:\n"
3635         "         * f(x, y) = u(x, y)² - v(x, y)\n"
3636         "         * ∂f/∂x = 2u · ∂u/∂x - ∂v/∂x\n"
3637         "         * ∂f/∂y = 2u · ∂u/∂y - ∂v/∂y\n"
3638         "         *\n"
3639         "         * For arcs:\n"
3640         "         * f(x, y) = u(x, y)² + v(x, y)² - 1\n"
3641         "         * ∂f/∂x = 2u · ∂u/∂x + 2v · ∂v/∂x\n"
3642         "         * ∂f/∂y = 2u · ∂u/∂y + 2v · ∂v/∂y */\n"
3643         "        uv = i.b;\n"
3644         "        du = float2(ddx(uv.x), ddy(uv.x));\n"
3645         "        dv = float2(ddx(uv.y), ddy(uv.y));\n"
3646         "\n"
3647         "        if (!is_arc)\n"
3648         "        {\n"
3649         "            df = 2.0f * uv.x * du - dv;\n"
3650         "\n"
3651         "            clip(dot(df, uv.zw));\n"
3652         "            clip(length(mul(i.stroke_transform, df)) - abs(uv.x * uv.x - uv.y));\n"
3653         "        }\n"
3654         "        else\n"
3655         "        {\n"
3656         "            df = 2.0f * uv.x * du + 2.0f * uv.y * dv;\n"
3657         "\n"
3658         "            clip(dot(df, uv.zw));\n"
3659         "            clip(length(mul(i.stroke_transform, df)) - abs(uv.x * uv.x + uv.y * uv.y - 1.0f));\n"
3660         "        }\n"
3661         "    }\n"
3662         "    else\n"
3663         "    {\n"
3664         "        /* Evaluate the implicit form of the curve in texture space.\n"
3665         "         * \"i.b.z\" determines which side of the curve is shaded. */\n"
3666         "        if (!is_arc)\n"
3667         "        {\n"
3668         "            clip((i.b.x * i.b.x - i.b.y) * i.b.z);\n"
3669         "        }\n"
3670         "        else\n"
3671         "        {\n"
3672         "            clip((i.b.x * i.b.x + i.b.y * i.b.y - 1.0) * i.b.z);\n"
3673         "        }\n"
3674         "    }\n"
3675         "\n"
3676         "    return colour;\n"
3677         "}\n";
3678     static const struct shape_info
3679     {
3680         enum d2d_shape_type shape_type;
3681         const D3D11_INPUT_ELEMENT_DESC *il_desc;
3682         unsigned int il_element_count;
3683         const char *name;
3684         const char *vs_code;
3685         size_t vs_code_size;
3686     }
3687     shape_info[] =
3688     {
3689         {D2D_SHAPE_TYPE_OUTLINE,        il_desc_outline,        ARRAY_SIZE(il_desc_outline),
3690          "outline",                     vs_code_outline,        sizeof(vs_code_outline) - 1},
3691         {D2D_SHAPE_TYPE_BEZIER_OUTLINE, il_desc_curve_outline,  ARRAY_SIZE(il_desc_curve_outline),
3692          "bezier_outline",              vs_code_bezier_outline, sizeof(vs_code_bezier_outline) - 1},
3693         {D2D_SHAPE_TYPE_ARC_OUTLINE,    il_desc_curve_outline,  ARRAY_SIZE(il_desc_curve_outline),
3694          "arc_outline",                 vs_code_arc_outline,    sizeof(vs_code_arc_outline) - 1},
3695         {D2D_SHAPE_TYPE_TRIANGLE,       il_desc_triangle,       ARRAY_SIZE(il_desc_triangle),
3696          "triangle",                    vs_code_triangle,       sizeof(vs_code_triangle) - 1},
3697         {D2D_SHAPE_TYPE_CURVE,          il_desc_curve,          ARRAY_SIZE(il_desc_curve),
3698          "curve",                       vs_code_curve,          sizeof(vs_code_curve) - 1},
3699     };
3700     static const struct
3701     {
3702         float x, y;
3703     }
3704     quad[] =
3705     {
3706         {-1.0f,  1.0f},
3707         {-1.0f, -1.0f},
3708         { 1.0f,  1.0f},
3709         { 1.0f, -1.0f},
3710     };
3711     static const UINT16 indices[] = {0, 1, 2, 2, 1, 3};
3712     static const D3D_FEATURE_LEVEL feature_levels = D3D_FEATURE_LEVEL_10_0;
3713
3714     render_target->ID2D1DeviceContext1_iface.lpVtbl = &d2d_device_context_vtbl;
3715     render_target->ID2D1GdiInteropRenderTarget_iface.lpVtbl = &d2d_gdi_interop_render_target_vtbl;
3716     render_target->IDWriteTextRenderer_iface.lpVtbl = &d2d_text_renderer_vtbl;
3717     render_target->IUnknown_iface.lpVtbl = &d2d_device_context_inner_unknown_vtbl;
3718     render_target->refcount = 1;
3719     ID2D1Device1_GetFactory(&device->ID2D1Device1_iface, &render_target->factory);
3720     render_target->device = device;
3721     ID2D1Device1_AddRef(&render_target->device->ID2D1Device1_iface);
3722
3723     factory = unsafe_impl_from_ID2D1Factory(render_target->factory);
3724     if (factory->factory_type == D2D1_FACTORY_TYPE_MULTI_THREADED)
3725         render_target->cs = &factory->cs;
3726
3727     render_target->outer_unknown = outer_unknown ? outer_unknown : &render_target->IUnknown_iface;
3728     render_target->ops = ops;
3729
3730     device_impl = unsafe_impl_from_ID2D1Device((ID2D1Device1 *)device);
3731     if (FAILED(hr = IDXGIDevice_QueryInterface(device_impl->dxgi_device,
3732             &IID_ID3D11Device1, (void **)&render_target->d3d_device)))
3733     {
3734         WARN("Failed to query ID3D11Device1 interface, hr %#lx.\n", hr);
3735         goto err;
3736     }
3737
3738     if (FAILED(hr = ID3D11Device1_CreateDeviceContextState(render_target->d3d_device,
3739             0, &feature_levels, 1, D3D11_SDK_VERSION, &IID_ID3D11Device1, NULL,
3740             &render_target->d3d_state)))
3741     {
3742         WARN("Failed to create device context state, hr %#lx.\n", hr);
3743         goto err;
3744     }
3745
3746     for (i = 0; i < ARRAY_SIZE(shape_info); ++i)
3747     {
3748         const struct shape_info *si = &shape_info[i];
3749
3750         if (FAILED(hr = D3DCompile(si->vs_code, si->vs_code_size, si->name, NULL, NULL,
3751                 "main", "vs_4_0", 0, 0, &compiled, NULL)))
3752         {
3753             WARN("Failed to compile shader for shape type %#x, hr %#lx.\n", si->shape_type, hr);
3754             goto err;
3755         }
3756
3757         if (FAILED(hr = ID3D11Device1_CreateInputLayout(render_target->d3d_device, si->il_desc, si->il_element_count,
3758                 ID3D10Blob_GetBufferPointer(compiled), ID3D10Blob_GetBufferSize(compiled),
3759                 &render_target->shape_resources[si->shape_type].il)))
3760         {
3761             WARN("Failed to create input layout for shape type %#x, hr %#lx.\n", si->shape_type, hr);
3762             ID3D10Blob_Release(compiled);
3763             goto err;
3764         }
3765
3766         if (FAILED(hr = ID3D11Device1_CreateVertexShader(render_target->d3d_device,
3767                 ID3D10Blob_GetBufferPointer(compiled), ID3D10Blob_GetBufferSize(compiled),
3768                 NULL, &render_target->shape_resources[si->shape_type].vs)))
3769         {
3770             WARN("Failed to create vertex shader for shape type %#x, hr %#lx.\n", si->shape_type, hr);
3771             ID3D10Blob_Release(compiled);
3772             goto err;
3773         }
3774
3775         ID3D10Blob_Release(compiled);
3776     }
3777
3778     buffer_desc.ByteWidth = sizeof(struct d2d_vs_cb);
3779     buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
3780     buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
3781     buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
3782     buffer_desc.MiscFlags = 0;
3783
3784     if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, NULL,
3785             &render_target->vs_cb)))
3786     {
3787         WARN("Failed to create constant buffer, hr %#lx.\n", hr);
3788         goto err;
3789     }
3790
3791     if (FAILED(hr = D3DCompile(ps_code, sizeof(ps_code) - 1, "ps", NULL, NULL, "main", "ps_4_0", 0, 0, &compiled, NULL)))
3792     {
3793         WARN("Failed to compile the pixel shader, hr %#lx.\n", hr);
3794         goto err;
3795     }
3796
3797     if (FAILED(hr = ID3D11Device1_CreatePixelShader(render_target->d3d_device,
3798             ID3D10Blob_GetBufferPointer(compiled), ID3D10Blob_GetBufferSize(compiled),
3799             NULL, &render_target->ps)))
3800     {
3801         WARN("Failed to create pixel shader, hr %#lx.\n", hr);
3802         ID3D10Blob_Release(compiled);
3803         goto err;
3804     }
3805
3806     ID3D10Blob_Release(compiled);
3807
3808     buffer_desc.ByteWidth = sizeof(struct d2d_ps_cb);
3809     buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
3810     buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
3811     buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
3812     buffer_desc.MiscFlags = 0;
3813
3814     if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device, &buffer_desc, NULL,
3815             &render_target->ps_cb)))
3816     {
3817         WARN("Failed to create constant buffer, hr %#lx.\n", hr);
3818         goto err;
3819     }
3820
3821     buffer_desc.ByteWidth = sizeof(indices);
3822     buffer_desc.Usage = D3D11_USAGE_DEFAULT;
3823     buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
3824     buffer_desc.CPUAccessFlags = 0;
3825     buffer_desc.MiscFlags = 0;
3826
3827     buffer_data.pSysMem = indices;
3828     buffer_data.SysMemPitch = 0;
3829     buffer_data.SysMemSlicePitch = 0;
3830
3831     if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device,
3832             &buffer_desc, &buffer_data, &render_target->ib)))
3833     {
3834         WARN("Failed to create clear index buffer, hr %#lx.\n", hr);
3835         goto err;
3836     }
3837
3838     buffer_desc.ByteWidth = sizeof(quad);
3839     buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
3840     buffer_data.pSysMem = quad;
3841
3842     render_target->vb_stride = sizeof(*quad);
3843     if (FAILED(hr = ID3D11Device1_CreateBuffer(render_target->d3d_device,
3844             &buffer_desc, &buffer_data, &render_target->vb)))
3845     {
3846         WARN("Failed to create clear vertex buffer, hr %#lx.\n", hr);
3847         goto err;
3848     }
3849
3850     rs_desc.FillMode = D3D11_FILL_SOLID;
3851     rs_desc.CullMode = D3D11_CULL_NONE;
3852     rs_desc.FrontCounterClockwise = FALSE;
3853     rs_desc.DepthBias = 0;
3854     rs_desc.DepthBiasClamp = 0.0f;
3855     rs_desc.SlopeScaledDepthBias = 0.0f;
3856     rs_desc.DepthClipEnable = TRUE;
3857     rs_desc.ScissorEnable = TRUE;
3858     rs_desc.MultisampleEnable = FALSE;
3859     rs_desc.AntialiasedLineEnable = FALSE;
3860     if (FAILED(hr = ID3D11Device1_CreateRasterizerState(render_target->d3d_device, &rs_desc, &render_target->rs)))
3861     {
3862         WARN("Failed to create clear rasteriser state, hr %#lx.\n", hr);
3863         goto err;
3864     }
3865
3866     if (FAILED(hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
3867             &IID_IDWriteFactory, (IUnknown **)&dwrite_factory)))
3868     {
3869         ERR("Failed to create dwrite factory, hr %#lx.\n", hr);
3870         goto err;
3871     }
3872
3873     hr = IDWriteFactory_CreateRenderingParams(dwrite_factory, &render_target->default_text_rendering_params);
3874     IDWriteFactory_Release(dwrite_factory);
3875     if (FAILED(hr))
3876     {
3877         ERR("Failed to create default text rendering parameters, hr %#lx.\n", hr);
3878         goto err;
3879     }
3880
3881     render_target->drawing_state.transform = identity;
3882
3883     if (!d2d_clip_stack_init(&render_target->clip_stack))
3884     {
3885         WARN("Failed to initialize clip stack.\n");
3886         hr = E_FAIL;
3887         goto err;
3888     }
3889
3890     render_target->desc.dpiX = 96.0f;
3891     render_target->desc.dpiY = 96.0f;
3892
3893     return S_OK;
3894
3895 err:
3896     if (render_target->default_text_rendering_params)
3897         IDWriteRenderingParams_Release(render_target->default_text_rendering_params);
3898     if (render_target->rs)
3899         ID3D11RasterizerState_Release(render_target->rs);
3900     if (render_target->vb)
3901         ID3D11Buffer_Release(render_target->vb);
3902     if (render_target->ib)
3903         ID3D11Buffer_Release(render_target->ib);
3904     if (render_target->ps_cb)
3905         ID3D11Buffer_Release(render_target->ps_cb);
3906     if (render_target->ps)
3907         ID3D11PixelShader_Release(render_target->ps);
3908     if (render_target->vs_cb)
3909         ID3D11Buffer_Release(render_target->vs_cb);
3910     for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i)
3911     {
3912         if (render_target->shape_resources[i].vs)
3913             ID3D11VertexShader_Release(render_target->shape_resources[i].vs);
3914         if (render_target->shape_resources[i].il)
3915             ID3D11InputLayout_Release(render_target->shape_resources[i].il);
3916     }
3917     if (render_target->d3d_state)
3918         ID3DDeviceContextState_Release(render_target->d3d_state);
3919     if (render_target->d3d_device)
3920         ID3D11Device1_Release(render_target->d3d_device);
3921     ID2D1Device1_Release(&render_target->device->ID2D1Device1_iface);
3922     ID2D1Factory_Release(render_target->factory);
3923     return hr;
3924 }
3925
3926 HRESULT d2d_d3d_create_render_target(struct d2d_device *device, IDXGISurface *surface, IUnknown *outer_unknown,
3927         const struct d2d_device_context_ops *ops, const D2D1_RENDER_TARGET_PROPERTIES *desc, void **render_target)
3928 {
3929     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
3930     struct d2d_device_context *object;
3931     ID2D1Bitmap1 *bitmap;
3932     HRESULT hr;
3933
3934     if (desc->type != D2D1_RENDER_TARGET_TYPE_DEFAULT && desc->type != D2D1_RENDER_TARGET_TYPE_HARDWARE)
3935         WARN("Ignoring render target type %#x.\n", desc->type);
3936     if (desc->usage != D2D1_RENDER_TARGET_USAGE_NONE)
3937         FIXME("Ignoring render target usage %#x.\n", desc->usage);
3938     if (desc->minLevel != D2D1_FEATURE_LEVEL_DEFAULT)
3939         WARN("Ignoring feature level %#x.\n", desc->minLevel);
3940
3941     bitmap_desc.dpiX = desc->dpiX;
3942     bitmap_desc.dpiY = desc->dpiY;
3943
3944     if (bitmap_desc.dpiX == 0.0f && bitmap_desc.dpiY == 0.0f)
3945     {
3946         bitmap_desc.dpiX = 96.0f;
3947         bitmap_desc.dpiY = 96.0f;
3948     }
3949     else if (bitmap_desc.dpiX <= 0.0f || bitmap_desc.dpiY <= 0.0f)
3950         return E_INVALIDARG;
3951
3952     if (!(object = calloc(1, sizeof(*object))))
3953         return E_OUTOFMEMORY;
3954
3955     if (FAILED(hr = d2d_device_context_init(object, device, outer_unknown, ops)))
3956     {
3957         WARN("Failed to initialise render target, hr %#lx.\n", hr);
3958         free(object);
3959         return hr;
3960     }
3961
3962     ID2D1DeviceContext1_SetDpi(&object->ID2D1DeviceContext1_iface, bitmap_desc.dpiX, bitmap_desc.dpiY);
3963
3964     if (surface)
3965     {
3966         bitmap_desc.pixelFormat = desc->pixelFormat;
3967         bitmap_desc.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW;
3968         if (desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE)
3969             bitmap_desc.bitmapOptions |= D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE;
3970         bitmap_desc.colorContext = NULL;
3971
3972         if (FAILED(hr = ID2D1DeviceContext1_CreateBitmapFromDxgiSurface(&object->ID2D1DeviceContext1_iface,
3973                 surface, &bitmap_desc, &bitmap)))
3974         {
3975             WARN("Failed to create target bitmap, hr %#lx.\n", hr);
3976             IUnknown_Release(&object->IUnknown_iface);
3977             return hr;
3978         }
3979
3980         ID2D1DeviceContext1_SetTarget(&object->ID2D1DeviceContext1_iface, (ID2D1Image *)bitmap);
3981         ID2D1Bitmap1_Release(bitmap);
3982     }
3983     else
3984         object->desc.pixelFormat = desc->pixelFormat;
3985
3986     TRACE("Created render target %p.\n", object);
3987     *render_target = outer_unknown ? &object->IUnknown_iface : (IUnknown *)&object->ID2D1DeviceContext1_iface;
3988
3989     return S_OK;
3990 }
3991
3992 static HRESULT WINAPI d2d_device_QueryInterface(ID2D1Device1 *iface, REFIID iid, void **out)
3993 {
3994     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
3995
3996     if (IsEqualGUID(iid, &IID_ID2D1Device1)
3997             || IsEqualGUID(iid, &IID_ID2D1Device)
3998             || IsEqualGUID(iid, &IID_ID2D1Resource)
3999             || IsEqualGUID(iid, &IID_IUnknown))
4000     {
4001         ID2D1Device1_AddRef(iface);
4002         *out = iface;
4003         return S_OK;
4004     }
4005
4006     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
4007
4008     *out = NULL;
4009     return E_NOINTERFACE;
4010 }
4011
4012 static ULONG WINAPI d2d_device_AddRef(ID2D1Device1 *iface)
4013 {
4014     struct d2d_device *device = impl_from_ID2D1Device(iface);
4015     ULONG refcount = InterlockedIncrement(&device->refcount);
4016
4017     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
4018
4019     return refcount;
4020 }
4021
4022 static ULONG WINAPI d2d_device_Release(ID2D1Device1 *iface)
4023 {
4024     struct d2d_device *device = impl_from_ID2D1Device(iface);
4025     ULONG refcount = InterlockedDecrement(&device->refcount);
4026     size_t i;
4027
4028     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
4029
4030     if (!refcount)
4031     {
4032         IDXGIDevice_Release(device->dxgi_device);
4033         ID2D1Factory1_Release(device->factory);
4034         for (i = 0; i < device->shaders.count; ++i)
4035             IUnknown_Release(device->shaders.objects[i].shader);
4036         free(device->shaders.objects);
4037         free(device);
4038     }
4039
4040     return refcount;
4041 }
4042
4043 static void WINAPI d2d_device_GetFactory(ID2D1Device1 *iface, ID2D1Factory **factory)
4044 {
4045     struct d2d_device *device = impl_from_ID2D1Device(iface);
4046
4047     TRACE("iface %p, factory %p.\n", iface, factory);
4048
4049     *factory = (ID2D1Factory *)device->factory;
4050     ID2D1Factory1_AddRef(device->factory);
4051 }
4052
4053 static HRESULT d2d_device_create_device_context(struct d2d_device *device,
4054         D2D1_DEVICE_CONTEXT_OPTIONS options, ID2D1DeviceContext1 **context)
4055 {
4056     struct d2d_device_context *object;
4057     HRESULT hr;
4058
4059     if (options)
4060         FIXME("Options are ignored %#x.\n", options);
4061
4062     if (!(object = calloc(1, sizeof(*object))))
4063         return E_OUTOFMEMORY;
4064
4065     if (FAILED(hr = d2d_device_context_init(object, device, NULL, NULL)))
4066     {
4067         WARN("Failed to initialise device context, hr %#lx.\n", hr);
4068         free(object);
4069         return hr;
4070     }
4071
4072     TRACE("Created device context %p.\n", object);
4073     *context = &object->ID2D1DeviceContext1_iface;
4074
4075     return S_OK;
4076 }
4077
4078 static HRESULT WINAPI d2d_device_CreateDeviceContext(ID2D1Device1 *iface, D2D1_DEVICE_CONTEXT_OPTIONS options,
4079         ID2D1DeviceContext **context)
4080 {
4081     struct d2d_device *device = impl_from_ID2D1Device(iface);
4082
4083     TRACE("iface %p, options %#x, context %p.\n", iface, options, context);
4084
4085     return d2d_device_create_device_context(device, options, (ID2D1DeviceContext1 **)context);
4086 }
4087
4088 static HRESULT WINAPI d2d_device_CreatePrintControl(ID2D1Device1 *iface, IWICImagingFactory *wic_factory,
4089         IPrintDocumentPackageTarget *document_target, const D2D1_PRINT_CONTROL_PROPERTIES *desc,
4090         ID2D1PrintControl **print_control)
4091 {
4092     FIXME("iface %p, wic_factory %p, document_target %p, desc %p, print_control %p stub!\n", iface, wic_factory,
4093             document_target, desc, print_control);
4094
4095     return E_NOTIMPL;
4096 }
4097
4098 static void WINAPI d2d_device_SetMaximumTextureMemory(ID2D1Device1 *iface, UINT64 max_texture_memory)
4099 {
4100     FIXME("iface %p, max_texture_memory %s stub!\n", iface, wine_dbgstr_longlong(max_texture_memory));
4101 }
4102
4103 static UINT64 WINAPI d2d_device_GetMaximumTextureMemory(ID2D1Device1 *iface)
4104 {
4105     FIXME("iface %p stub!\n", iface);
4106
4107     return 0;
4108 }
4109
4110 static HRESULT WINAPI d2d_device_ClearResources(ID2D1Device1 *iface, UINT msec_since_use)
4111 {
4112     FIXME("iface %p, msec_since_use %u stub!\n", iface, msec_since_use);
4113
4114     return E_NOTIMPL;
4115 }
4116
4117 static D2D1_RENDERING_PRIORITY WINAPI d2d_device_GetRenderingPriority(ID2D1Device1 *iface)
4118 {
4119     FIXME("iface %p stub!\n", iface);
4120
4121     return D2D1_RENDERING_PRIORITY_NORMAL;
4122 }
4123
4124 static void WINAPI d2d_device_SetRenderingPriority(ID2D1Device1 *iface, D2D1_RENDERING_PRIORITY priority)
4125 {
4126     FIXME("iface %p, priority %#x stub!\n", iface, priority);
4127 }
4128
4129 static HRESULT WINAPI d2d_device_CreateDeviceContext1(ID2D1Device1 *iface, D2D1_DEVICE_CONTEXT_OPTIONS options,
4130         ID2D1DeviceContext1 **context)
4131 {
4132     struct d2d_device *device = impl_from_ID2D1Device(iface);
4133
4134     TRACE("iface %p, options %#x, context %p.\n", iface, options, context);
4135
4136     return d2d_device_create_device_context(device, options, context);
4137 }
4138
4139 static const struct ID2D1Device1Vtbl d2d_device_vtbl =
4140 {
4141     d2d_device_QueryInterface,
4142     d2d_device_AddRef,
4143     d2d_device_Release,
4144     d2d_device_GetFactory,
4145     d2d_device_CreateDeviceContext,
4146     d2d_device_CreatePrintControl,
4147     d2d_device_SetMaximumTextureMemory,
4148     d2d_device_GetMaximumTextureMemory,
4149     d2d_device_ClearResources,
4150     d2d_device_GetRenderingPriority,
4151     d2d_device_SetRenderingPriority,
4152     d2d_device_CreateDeviceContext1,
4153 };
4154
4155 struct d2d_device *unsafe_impl_from_ID2D1Device(ID2D1Device1 *iface)
4156 {
4157     if (!iface)
4158         return NULL;
4159     assert(iface->lpVtbl == &d2d_device_vtbl);
4160     return CONTAINING_RECORD(iface, struct d2d_device, ID2D1Device1_iface);
4161 }
4162
4163 void d2d_device_init(struct d2d_device *device, ID2D1Factory1 *iface, IDXGIDevice *dxgi_device)
4164 {
4165     device->ID2D1Device1_iface.lpVtbl = &d2d_device_vtbl;
4166     device->refcount = 1;
4167     device->factory = iface;
4168     ID2D1Factory1_AddRef(device->factory);
4169     device->dxgi_device = dxgi_device;
4170     IDXGIDevice_AddRef(device->dxgi_device);
4171 }
4172
4173 HRESULT d2d_device_add_shader(struct d2d_device *device, REFGUID shader_id, IUnknown *shader)
4174 {
4175     struct d2d_shader *entry;
4176
4177     if (!d2d_array_reserve((void **)&device->shaders.objects, &device->shaders.size,
4178             device->shaders.count + 1, sizeof(*device->shaders.objects)))
4179     {
4180         WARN("Failed to resize shaders array.\n");
4181         return E_OUTOFMEMORY;
4182     }
4183
4184     entry = &device->shaders.objects[device->shaders.count++];
4185     entry->id = *shader_id;
4186     entry->shader = shader;
4187     IUnknown_AddRef(entry->shader);
4188
4189     return S_OK;
4190 }
4191
4192 BOOL d2d_device_is_shader_loaded(struct d2d_device *device, REFGUID shader_id)
4193 {
4194      size_t i;
4195
4196      for (i = 0; i < device->shaders.count; ++i)
4197      {
4198          if (IsEqualGUID(shader_id, &device->shaders.objects[i].id))
4199              return TRUE;
4200      }
4201
4202      return FALSE;
4203 }