2 * Copyright 2014 Henri Verbeet for CodeWeavers
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.
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.
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
19 #define D2D1_INIT_GUID
20 #include "d2d1_private.h"
23 #include "wine/list.h"
25 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
26 WINE_DEFAULT_DEBUG_CHANNEL(d2d
);
28 struct d2d_settings d2d_settings
=
30 ~0u, /* No ID2D1Factory version limit by default. */
33 static void d2d_effect_registration_cleanup(struct d2d_effect_registration
*reg
)
35 d2d_effect_properties_cleanup(®
->properties
);
41 ID2D1Factory3 ID2D1Factory3_iface
;
42 ID2D1Multithread ID2D1Multithread_iface
;
45 ID3D10Device1
*device
;
51 INIT_ONCE init_builtins
;
56 static inline struct d2d_factory
*impl_from_ID2D1Factory3(ID2D1Factory3
*iface
)
58 return CONTAINING_RECORD(iface
, struct d2d_factory
, ID2D1Factory3_iface
);
61 static inline struct d2d_factory
*unsafe_impl_from_ID2D1Factory(ID2D1Factory
*iface
)
63 return CONTAINING_RECORD(iface
, struct d2d_factory
, ID2D1Factory3_iface
);
66 static inline struct d2d_factory
*impl_from_ID2D1Multithread(ID2D1Multithread
*iface
)
68 return CONTAINING_RECORD(iface
, struct d2d_factory
, ID2D1Multithread_iface
);
71 static BOOL WINAPI
d2d_factory_builtins_initonce(INIT_ONCE
*once
, void *param
, void **context
)
73 d2d_effects_init_builtins(param
);
78 static void d2d_factory_init_builtin_effects(struct d2d_factory
*factory
)
80 InitOnceExecuteOnce(&factory
->init_builtins
, d2d_factory_builtins_initonce
, factory
, NULL
);
83 void d2d_factory_register_effect(struct d2d_factory
*factory
, struct d2d_effect_registration
*effect
)
85 list_add_tail(&factory
->effects
, &effect
->entry
);
88 struct d2d_effect_registration
* d2d_factory_get_registered_effect(ID2D1Factory
*iface
,
91 struct d2d_factory
*factory
= unsafe_impl_from_ID2D1Factory(iface
);
92 struct d2d_effect_registration
*reg
;
94 d2d_effects_init_builtins(factory
);
96 LIST_FOR_EACH_ENTRY(reg
, &factory
->effects
, struct d2d_effect_registration
, entry
)
98 if (IsEqualGUID(id
, ®
->id
)) return reg
;
104 static HRESULT
d2d_factory_reload_sysmetrics(struct d2d_factory
*factory
)
108 if (!(hdc
= GetDC(NULL
)))
110 factory
->dpi_x
= factory
->dpi_y
= 96.0f
;
114 factory
->dpi_x
= GetDeviceCaps(hdc
, LOGPIXELSX
);
115 factory
->dpi_y
= GetDeviceCaps(hdc
, LOGPIXELSY
);
117 ReleaseDC(NULL
, hdc
);
122 static HRESULT STDMETHODCALLTYPE
d2d_factory_QueryInterface(ID2D1Factory3
*iface
, REFIID iid
, void **out
)
124 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
126 TRACE("iface %p, iid %s, out %p.\n", iface
, debugstr_guid(iid
), out
);
128 if ((IsEqualGUID(iid
, &IID_ID2D1Factory3
) && d2d_settings
.max_version_factory
>= 3)
129 || (IsEqualGUID(iid
, &IID_ID2D1Factory2
) && d2d_settings
.max_version_factory
>= 2)
130 || (IsEqualGUID(iid
, &IID_ID2D1Factory1
) && d2d_settings
.max_version_factory
>= 1)
131 || IsEqualGUID(iid
, &IID_ID2D1Factory
)
132 || IsEqualGUID(iid
, &IID_IUnknown
))
134 ID2D1Factory3_AddRef(iface
);
138 else if (IsEqualGUID(iid
, &IID_ID2D1Multithread
))
140 ID2D1Factory3_AddRef(iface
);
141 *out
= &factory
->ID2D1Multithread_iface
;
145 WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid
));
148 return E_NOINTERFACE
;
151 static ULONG STDMETHODCALLTYPE
d2d_factory_AddRef(ID2D1Factory3
*iface
)
153 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
154 ULONG refcount
= InterlockedIncrement(&factory
->refcount
);
156 TRACE("%p increasing refcount to %lu.\n", iface
, refcount
);
161 static ULONG STDMETHODCALLTYPE
d2d_factory_Release(ID2D1Factory3
*iface
)
163 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
164 ULONG refcount
= InterlockedDecrement(&factory
->refcount
);
165 struct d2d_effect_registration
*reg
, *reg2
;
167 TRACE("%p decreasing refcount to %lu.\n", iface
, refcount
);
172 ID3D10Device1_Release(factory
->device
);
173 LIST_FOR_EACH_ENTRY_SAFE(reg
, reg2
, &factory
->effects
, struct d2d_effect_registration
, entry
)
175 d2d_effect_registration_cleanup(reg
);
177 DeleteCriticalSection(&factory
->cs
);
184 static HRESULT STDMETHODCALLTYPE
d2d_factory_ReloadSystemMetrics(ID2D1Factory3
*iface
)
186 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
188 TRACE("iface %p.\n", iface
);
190 return d2d_factory_reload_sysmetrics(factory
);
193 static void STDMETHODCALLTYPE
d2d_factory_GetDesktopDpi(ID2D1Factory3
*iface
, float *dpi_x
, float *dpi_y
)
195 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
197 TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface
, dpi_x
, dpi_y
);
199 *dpi_x
= factory
->dpi_x
;
200 *dpi_y
= factory
->dpi_y
;
203 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateRectangleGeometry(ID2D1Factory3
*iface
,
204 const D2D1_RECT_F
*rect
, ID2D1RectangleGeometry
**geometry
)
206 struct d2d_geometry
*object
;
209 TRACE("iface %p, rect %s, geometry %p.\n", iface
, debug_d2d_rect_f(rect
), geometry
);
211 if (!(object
= calloc(1, sizeof(*object
))))
212 return E_OUTOFMEMORY
;
214 if (FAILED(hr
= d2d_rectangle_geometry_init(object
, (ID2D1Factory
*)iface
, rect
)))
216 WARN("Failed to initialise rectangle geometry, hr %#lx.\n", hr
);
221 TRACE("Created rectangle geometry %p.\n", object
);
222 *geometry
= (ID2D1RectangleGeometry
*)&object
->ID2D1Geometry_iface
;
227 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateRoundedRectangleGeometry(ID2D1Factory3
*iface
,
228 const D2D1_ROUNDED_RECT
*rounded_rect
, ID2D1RoundedRectangleGeometry
**geometry
)
230 struct d2d_geometry
*object
;
233 TRACE("iface %p, rounded_rect %s, geometry %p.\n", iface
, debug_d2d_rounded_rect(rounded_rect
), geometry
);
235 if (!(object
= calloc(1, sizeof(*object
))))
236 return E_OUTOFMEMORY
;
238 if (FAILED(hr
= d2d_rounded_rectangle_geometry_init(object
, (ID2D1Factory
*)iface
, rounded_rect
)))
240 WARN("Failed to initialise rounded rectangle geometry, hr %#lx.\n", hr
);
245 TRACE("Created rounded rectangle geometry %p.\n", object
);
246 *geometry
= (ID2D1RoundedRectangleGeometry
*)&object
->ID2D1Geometry_iface
;
251 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateEllipseGeometry(ID2D1Factory3
*iface
,
252 const D2D1_ELLIPSE
*ellipse
, ID2D1EllipseGeometry
**geometry
)
254 struct d2d_geometry
*object
;
257 TRACE("iface %p, ellipse %s, geometry %p.\n", iface
, debug_d2d_ellipse(ellipse
), geometry
);
259 if (!(object
= calloc(1, sizeof(*object
))))
260 return E_OUTOFMEMORY
;
262 if (FAILED(hr
= d2d_ellipse_geometry_init(object
, (ID2D1Factory
*)iface
, ellipse
)))
264 WARN("Failed to initialise ellipse geometry, hr %#lx.\n", hr
);
269 TRACE("Created ellipse geometry %p.\n", object
);
270 *geometry
= (ID2D1EllipseGeometry
*)&object
->ID2D1Geometry_iface
;
275 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateGeometryGroup(ID2D1Factory3
*iface
,
276 D2D1_FILL_MODE fill_mode
, ID2D1Geometry
**geometries
, UINT32 geometry_count
, ID2D1GeometryGroup
**group
)
278 struct d2d_geometry
*object
;
281 TRACE("iface %p, fill_mode %#x, geometries %p, geometry_count %u, group %p.\n",
282 iface
, fill_mode
, geometries
, geometry_count
, group
);
284 if (!(object
= calloc(1, sizeof(*object
))))
285 return E_OUTOFMEMORY
;
287 if (FAILED(hr
= d2d_geometry_group_init(object
, (ID2D1Factory
*)iface
, fill_mode
, geometries
, geometry_count
)))
289 WARN("Failed to initialise geometry group, hr %#lx.\n", hr
);
294 TRACE("Created geometry group %p.\n", object
);
295 *group
= (ID2D1GeometryGroup
*)&object
->ID2D1Geometry_iface
;
300 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateTransformedGeometry(ID2D1Factory3
*iface
,
301 ID2D1Geometry
*src_geometry
, const D2D1_MATRIX_3X2_F
*transform
,
302 ID2D1TransformedGeometry
**transformed_geometry
)
304 struct d2d_geometry
*object
;
306 TRACE("iface %p, src_geometry %p, transform %p, transformed_geometry %p.\n",
307 iface
, src_geometry
, transform
, transformed_geometry
);
309 if (!(object
= calloc(1, sizeof(*object
))))
310 return E_OUTOFMEMORY
;
312 d2d_transformed_geometry_init(object
, (ID2D1Factory
*)iface
, src_geometry
, transform
);
314 TRACE("Created transformed geometry %p.\n", object
);
315 *transformed_geometry
= (ID2D1TransformedGeometry
*)&object
->ID2D1Geometry_iface
;
320 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreatePathGeometry(ID2D1Factory3
*iface
, ID2D1PathGeometry
**geometry
)
322 struct d2d_geometry
*object
;
324 TRACE("iface %p, geometry %p.\n", iface
, geometry
);
326 if (!(object
= calloc(1, sizeof(*object
))))
327 return E_OUTOFMEMORY
;
329 d2d_path_geometry_init(object
, (ID2D1Factory
*)iface
);
331 TRACE("Created path geometry %p.\n", object
);
332 *geometry
= (ID2D1PathGeometry
*)&object
->ID2D1Geometry_iface
;
337 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateStrokeStyle(ID2D1Factory3
*iface
,
338 const D2D1_STROKE_STYLE_PROPERTIES
*desc
, const float *dashes
, UINT32 dash_count
,
339 ID2D1StrokeStyle
**stroke_style
)
341 struct d2d_stroke_style
*object
;
342 D2D1_STROKE_STYLE_PROPERTIES1 desc1
;
345 TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
346 iface
, desc
, dashes
, dash_count
, stroke_style
);
348 if (!(object
= calloc(1, sizeof(*object
))))
349 return E_OUTOFMEMORY
;
351 desc1
.startCap
= desc
->startCap
;
352 desc1
.endCap
= desc
->endCap
;
353 desc1
.dashCap
= desc
->dashCap
;
354 desc1
.lineJoin
= desc
->lineJoin
;
355 desc1
.miterLimit
= desc
->miterLimit
;
356 desc1
.dashStyle
= desc
->dashStyle
;
357 desc1
.dashOffset
= desc
->dashOffset
;
358 desc1
.transformType
= D2D1_STROKE_TRANSFORM_TYPE_NORMAL
;
360 if (FAILED(hr
= d2d_stroke_style_init(object
, (ID2D1Factory
*)iface
, &desc1
, dashes
, dash_count
)))
362 WARN("Failed to initialise stroke style, hr %#lx.\n", hr
);
367 TRACE("Created stroke style %p.\n", object
);
368 *stroke_style
= (ID2D1StrokeStyle
*)&object
->ID2D1StrokeStyle1_iface
;
373 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateDrawingStateBlock(ID2D1Factory3
*iface
,
374 const D2D1_DRAWING_STATE_DESCRIPTION
*desc
, IDWriteRenderingParams
*text_rendering_params
,
375 ID2D1DrawingStateBlock
**state_block
)
377 D2D1_DRAWING_STATE_DESCRIPTION1 state_desc
;
378 struct d2d_state_block
*object
;
380 TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
381 iface
, desc
, text_rendering_params
, state_block
);
383 if (!(object
= calloc(1, sizeof(*object
))))
384 return E_OUTOFMEMORY
;
388 memcpy(&state_desc
, desc
, sizeof(*desc
));
389 state_desc
.primitiveBlend
= D2D1_PRIMITIVE_BLEND_SOURCE_OVER
;
390 state_desc
.unitMode
= D2D1_UNIT_MODE_DIPS
;
393 d2d_state_block_init(object
, (ID2D1Factory
*)iface
, desc
? &state_desc
: NULL
, text_rendering_params
);
395 TRACE("Created state block %p.\n", object
);
396 *state_block
= (ID2D1DrawingStateBlock
*)&object
->ID2D1DrawingStateBlock1_iface
;
401 static HRESULT
d2d_factory_get_device(struct d2d_factory
*factory
, ID3D10Device1
**device
)
405 if (!factory
->device
&& FAILED(hr
= D3D10CreateDevice1(NULL
, D3D10_DRIVER_TYPE_HARDWARE
, NULL
, D3D10_CREATE_DEVICE_BGRA_SUPPORT
,
406 D3D10_FEATURE_LEVEL_10_0
, D3D10_1_SDK_VERSION
, &factory
->device
)))
407 WARN("Failed to create device, hr %#lx.\n", hr
);
409 *device
= factory
->device
;
413 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateWicBitmapRenderTarget(ID2D1Factory3
*iface
,
414 IWICBitmap
*target
, const D2D1_RENDER_TARGET_PROPERTIES
*desc
, ID2D1RenderTarget
**render_target
)
416 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
417 struct d2d_wic_render_target
*object
;
418 ID3D10Device1
*device
;
421 TRACE("iface %p, target %p, desc %p, render_target %p.\n", iface
, target
, desc
, render_target
);
423 if (!(object
= calloc(1, sizeof(*object
))))
424 return E_OUTOFMEMORY
;
426 if (FAILED(hr
= d2d_factory_get_device(factory
, &device
)))
432 if (FAILED(hr
= d2d_wic_render_target_init(object
, (ID2D1Factory1
*)iface
, device
, target
, desc
)))
434 WARN("Failed to initialise render target, hr %#lx.\n", hr
);
439 TRACE("Created render target %p.\n", object
);
440 *render_target
= object
->dxgi_target
;
445 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateHwndRenderTarget(ID2D1Factory3
*iface
,
446 const D2D1_RENDER_TARGET_PROPERTIES
*desc
, const D2D1_HWND_RENDER_TARGET_PROPERTIES
*hwnd_rt_desc
,
447 ID2D1HwndRenderTarget
**render_target
)
449 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
450 struct d2d_hwnd_render_target
*object
;
451 ID3D10Device1
*device
;
454 TRACE("iface %p, desc %p, hwnd_rt_desc %p, render_target %p.\n", iface
, desc
, hwnd_rt_desc
, render_target
);
456 if (FAILED(hr
= d2d_factory_get_device(factory
, &device
)))
459 if (!(object
= calloc(1, sizeof(*object
))))
460 return E_OUTOFMEMORY
;
462 if (FAILED(hr
= d2d_hwnd_render_target_init(object
, (ID2D1Factory1
*)iface
, device
, desc
, hwnd_rt_desc
)))
464 WARN("Failed to initialise render target, hr %#lx.\n", hr
);
469 TRACE("Created render target %p.\n", object
);
470 *render_target
= &object
->ID2D1HwndRenderTarget_iface
;
475 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateDxgiSurfaceRenderTarget(ID2D1Factory3
*iface
,
476 IDXGISurface
*surface
, const D2D1_RENDER_TARGET_PROPERTIES
*desc
, ID2D1RenderTarget
**render_target
)
478 IDXGIDevice
*dxgi_device
;
482 TRACE("iface %p, surface %p, desc %p, render_target %p.\n", iface
, surface
, desc
, render_target
);
484 if (FAILED(hr
= IDXGISurface_GetDevice(surface
, &IID_IDXGIDevice
, (void **)&dxgi_device
)))
486 WARN("Failed to get DXGI device, hr %#lx.\n", hr
);
490 hr
= ID2D1Factory1_CreateDevice((ID2D1Factory1
*)iface
, dxgi_device
, &device
);
491 IDXGIDevice_Release(dxgi_device
);
494 WARN("Failed to create D2D device, hr %#lx.\n", hr
);
498 hr
= d2d_d3d_create_render_target(device
, surface
, NULL
, NULL
, desc
, (void **)render_target
);
499 ID2D1Device_Release(device
);
503 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateDCRenderTarget(ID2D1Factory3
*iface
,
504 const D2D1_RENDER_TARGET_PROPERTIES
*desc
, ID2D1DCRenderTarget
**render_target
)
506 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
507 struct d2d_dc_render_target
*object
;
508 ID3D10Device1
*device
;
511 TRACE("iface %p, desc %p, render_target %p.\n", iface
, desc
, render_target
);
513 if (FAILED(hr
= d2d_factory_get_device(factory
, &device
)))
516 if (!(object
= calloc(1, sizeof(*object
))))
517 return E_OUTOFMEMORY
;
519 if (FAILED(hr
= d2d_dc_render_target_init(object
, (ID2D1Factory1
*)iface
, device
, desc
)))
521 WARN("Failed to initialise render target, hr %#lx.\n", hr
);
526 TRACE("Created render target %p.\n", object
);
527 *render_target
= &object
->ID2D1DCRenderTarget_iface
;
532 static HRESULT
d2d_factory_create_device(ID2D1Factory3
*iface
, IDXGIDevice
*dxgi_device
,
533 ID2D1Device1
**device
) {
534 struct d2d_device
*object
;
536 if (!(object
= calloc(1, sizeof(*object
))))
537 return E_OUTOFMEMORY
;
539 d2d_device_init(object
, (ID2D1Factory1
*)iface
, dxgi_device
);
541 TRACE("Create device %p.\n", object
);
542 *device
= &object
->ID2D1Device1_iface
;
547 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateDevice(ID2D1Factory3
*iface
,
548 IDXGIDevice
*dxgi_device
, ID2D1Device
**device
)
550 TRACE("iface %p, dxgi_device %p, device %p.\n", iface
, dxgi_device
, device
);
552 return d2d_factory_create_device(iface
, dxgi_device
, (ID2D1Device1
**)device
);
555 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateStrokeStyle1(ID2D1Factory3
*iface
,
556 const D2D1_STROKE_STYLE_PROPERTIES1
*desc
, const float *dashes
, UINT32 dash_count
,
557 ID2D1StrokeStyle1
**stroke_style
)
559 struct d2d_stroke_style
*object
;
562 TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
563 iface
, desc
, dashes
, dash_count
, stroke_style
);
565 if (!(object
= calloc(1, sizeof(*object
))))
566 return E_OUTOFMEMORY
;
568 if (FAILED(hr
= d2d_stroke_style_init(object
, (ID2D1Factory
*)iface
,
569 desc
, dashes
, dash_count
)))
571 WARN("Failed to initialise stroke style, hr %#lx.\n", hr
);
576 TRACE("Created stroke style %p.\n", object
);
577 *stroke_style
= &object
->ID2D1StrokeStyle1_iface
;
582 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreatePathGeometry1(ID2D1Factory3
*iface
, ID2D1PathGeometry1
**geometry
)
584 struct d2d_geometry
*object
;
586 TRACE("iface %p, geometry %p.\n", iface
, geometry
);
588 if (!(object
= calloc(1, sizeof(*object
))))
589 return E_OUTOFMEMORY
;
591 d2d_path_geometry_init(object
, (ID2D1Factory
*)iface
);
593 TRACE("Created path geometry %p.\n", object
);
594 *geometry
= (ID2D1PathGeometry1
*)&object
->ID2D1Geometry_iface
;
599 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateDrawingStateBlock1(ID2D1Factory3
*iface
,
600 const D2D1_DRAWING_STATE_DESCRIPTION1
*desc
, IDWriteRenderingParams
*text_rendering_params
,
601 ID2D1DrawingStateBlock1
**state_block
)
603 struct d2d_state_block
*object
;
605 TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
606 iface
, desc
, text_rendering_params
, state_block
);
608 if (!(object
= calloc(1, sizeof(*object
))))
609 return E_OUTOFMEMORY
;
611 d2d_state_block_init(object
, (ID2D1Factory
*)iface
, desc
, text_rendering_params
);
613 TRACE("Created state block %p.\n", object
);
614 *state_block
= &object
->ID2D1DrawingStateBlock1_iface
;
619 static HRESULT STDMETHODCALLTYPE
d2d_factory_CreateGdiMetafile(ID2D1Factory3
*iface
,
620 IStream
*stream
, ID2D1GdiMetafile
**metafile
)
622 FIXME("iface %p, stream %p, metafile %p stub!\n", iface
, stream
, metafile
);
627 static HRESULT
parse_effect_get_next_xml_node(IXmlReader
*reader
, XmlNodeType expected_type
,
628 const WCHAR
*expected_name
, unsigned int *depth
)
630 const WCHAR
*node_name
;
631 XmlNodeType node_type
;
634 assert(expected_type
!= XmlNodeType_Whitespace
);
636 while ((hr
= IXmlReader_Read(reader
, &node_type
)) == S_OK
)
638 if (node_type
== XmlNodeType_Whitespace
)
641 if (expected_type
!= XmlNodeType_None
&& node_type
!= expected_type
)
642 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
646 if (FAILED(hr
= IXmlReader_GetLocalName(reader
, &node_name
, NULL
)))
649 if (wcscmp(node_name
, expected_name
))
650 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
654 IXmlReader_GetDepth(reader
, depth
);
661 static HRESULT
parse_effect_skip_element(IXmlReader
*reader
, unsigned int element_depth
)
663 XmlNodeType node_type
;
667 if (IXmlReader_IsEmptyElement(reader
)) return S_OK
;
669 while ((hr
= IXmlReader_Read(reader
, &node_type
)) == S_OK
)
671 IXmlReader_GetDepth(reader
, &depth
);
672 if (node_type
== XmlNodeType_EndElement
&& depth
== element_depth
+ 1)
681 static HRESULT
parse_effect_get_attribute(IXmlReader
*reader
, const WCHAR
*name
, WCHAR
**ret
)
687 if (IXmlReader_MoveToAttributeByName(reader
, name
, NULL
) != S_OK
)
689 if (IXmlReader_GetValue(reader
, &value
, NULL
) != S_OK
)
691 if (!(*ret
= wcsdup(value
)))
692 return E_OUTOFMEMORY
;
697 static HRESULT
parse_effect_get_property_type(IXmlReader
*reader
, D2D1_PROPERTY_TYPE
*type
)
699 static const WCHAR
*types
[] =
701 L
"", /* D2D1_PROPERTY_TYPE_UNKNOWN */
702 L
"string", /* D2D1_PROPERTY_TYPE_STRING */
703 L
"bool", /* D2D1_PROPERTY_TYPE_BOOL */
704 L
"uint32", /* D2D1_PROPERTY_TYPE_UINT32 */
705 L
"int32", /* D2D1_PROPERTY_TYPE_INT32 */
706 L
"float", /* D2D1_PROPERTY_TYPE_FLOAT */
707 L
"vector2", /* D2D1_PROPERTY_TYPE_VECTOR2 */
708 L
"vector3", /* D2D1_PROPERTY_TYPE_VECTOR3 */
709 L
"vector4", /* D2D1_PROPERTY_TYPE_VECTOR4 */
710 L
"blob", /* D2D1_PROPERTY_TYPE_BLOB */
711 L
"iunknown", /* D2D1_PROPERTY_TYPE_IUNKNOWN */
712 L
"enum", /* D2D1_PROPERTY_TYPE_ENUM */
713 L
"array", /* D2D1_PROPERTY_TYPE_ARRAY */
714 L
"clsid", /* D2D1_PROPERTY_TYPE_CLSID */
715 L
"matrix3x2", /* D2D1_PROPERTY_TYPE_MATRIX_3X2 */
716 L
"matrix4x3", /* D2D1_PROPERTY_TYPE_MATRIX_4X3 */
717 L
"matrix4x4", /* D2D1_PROPERTY_TYPE_MATRIX_4X4 */
718 L
"matrix5x4", /* D2D1_PROPERTY_TYPE_MATRIX_5X4 */
719 L
"colorcontext", /* D2D1_PROPERTY_TYPE_COLOR_CONTEXT */
725 if (FAILED(hr
= parse_effect_get_attribute(reader
, L
"type", &value
))) return hr
;
727 *type
= D2D1_PROPERTY_TYPE_UNKNOWN
;
729 for (i
= 0; i
< ARRAY_SIZE(types
); ++i
)
731 if (!wcscmp(value
, types
[i
]))
740 return *type
== D2D1_PROPERTY_TYPE_UNKNOWN
? E_INVALIDARG
: S_OK
;
743 static struct d2d_effect_property
* parse_effect_get_property(const struct d2d_effect_registration
*effect
,
748 for (i
= 0; i
< effect
->properties
.count
; ++i
)
750 if (!wcscmp(name
, effect
->properties
.properties
[i
].name
))
751 return &effect
->properties
.properties
[i
];
757 static UINT32
parse_effect_get_property_index(struct d2d_effect_properties
*props
,
760 if (!wcscmp(name
, L
"DisplayName")) return D2D1_PROPERTY_DISPLAYNAME
;
761 if (!wcscmp(name
, L
"Author")) return D2D1_PROPERTY_AUTHOR
;
762 if (!wcscmp(name
, L
"Category")) return D2D1_PROPERTY_CATEGORY
;
763 if (!wcscmp(name
, L
"Description")) return D2D1_PROPERTY_DESCRIPTION
;
764 return props
->custom_count
;
767 static HRESULT
parse_effect_property(IXmlReader
*reader
, struct d2d_effect_registration
*effect
)
769 WCHAR
*name
= NULL
, *value
= NULL
;
770 D2D1_PROPERTY_TYPE type
;
775 if (FAILED(hr
= parse_effect_get_attribute(reader
, L
"name", &name
)))
778 if (FAILED(hr
= parse_effect_get_property_type(reader
, &type
)))
784 /* Check for duplicates. */
785 if (parse_effect_get_property(effect
, name
))
788 parse_effect_get_attribute(reader
, L
"value", &value
);
792 /* FIXME: sub properties are ignored */
793 IXmlReader_MoveToElement(reader
);
794 IXmlReader_GetDepth(reader
, &depth
);
795 hr
= parse_effect_skip_element(reader
, depth
);
800 index
= parse_effect_get_property_index(&effect
->properties
, name
);
801 hr
= d2d_effect_properties_add(&effect
->properties
, name
, index
, type
, value
);
810 static HRESULT
parse_effect_inputs(IXmlReader
*reader
, struct d2d_effect_registration
*effect
)
812 struct d2d_effect_properties
*subproperties
;
813 unsigned int depth
, input_count
= 0;
814 struct d2d_effect_property
*inputs
;
815 XmlNodeType node_type
;
820 if (FAILED(hr
= d2d_effect_properties_add(&effect
->properties
, L
"Inputs",
821 D2D1_PROPERTY_INPUTS
, D2D1_PROPERTY_TYPE_ARRAY
, NULL
)))
824 if (!(inputs
= d2d_effect_properties_get_property_by_name(&effect
->properties
, L
"Inputs")))
826 if (!(inputs
->subproperties
= calloc(1, sizeof(*inputs
->subproperties
))))
827 return E_OUTOFMEMORY
;
828 subproperties
= inputs
->subproperties
;
830 d2d_effect_subproperties_add(subproperties
, L
"IsReadOnly", D2D1_SUBPROPERTY_ISREADONLY
,
831 D2D1_PROPERTY_TYPE_BOOL
, L
"true");
832 d2d_effect_subproperties_add(subproperties
, L
"DisplayName", D2D1_SUBPROPERTY_DISPLAYNAME
,
833 D2D1_PROPERTY_TYPE_STRING
, L
"Inputs");
835 if (IXmlReader_IsEmptyElement(reader
)) return S_OK
;
837 while (parse_effect_get_next_xml_node(reader
, XmlNodeType_None
, L
"Input", &depth
) == S_OK
)
839 if (FAILED(hr
= IXmlReader_GetNodeType(reader
, &node_type
))) return hr
;
840 if (node_type
== XmlNodeType_EndElement
) continue;
841 if (node_type
!= XmlNodeType_Element
) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
843 if (FAILED(hr
= parse_effect_get_attribute(reader
, L
"name", &name
))) return hr
;
845 swprintf(nameW
, ARRAY_SIZE(nameW
), L
"%lu", input_count
);
846 d2d_effect_subproperties_add(subproperties
, nameW
, input_count
, D2D1_PROPERTY_TYPE_STRING
, name
);
851 *(UINT32
*)(effect
->properties
.data
.ptr
+ inputs
->data
.offset
) = input_count
;
853 if (FAILED(hr
= IXmlReader_GetNodeType(reader
, &node_type
))) return hr
;
854 if (node_type
!= XmlNodeType_EndElement
) return HRESULT_FROM_WIN32(ERROR_NOT_FOUND
);
859 static HRESULT
parse_effect_xml(IXmlReader
*reader
, struct d2d_effect_registration
*effect
)
861 const WCHAR
*node_name
;
862 XmlNodeType node_type
;
866 /* Xml declaration node is mandatory. */
867 if ((hr
= parse_effect_get_next_xml_node(reader
, XmlNodeType_XmlDeclaration
, L
"xml", NULL
)) != S_OK
)
870 /* Top level "Effect" element. */
871 if ((hr
= parse_effect_get_next_xml_node(reader
, XmlNodeType_Element
, L
"Effect", NULL
)) != S_OK
)
874 /* Loop inside effect node */
875 while ((hr
= parse_effect_get_next_xml_node(reader
, XmlNodeType_None
, NULL
, &depth
)) == S_OK
)
877 if (FAILED(hr
= IXmlReader_GetNodeType(reader
, &node_type
))) return hr
;
878 if (node_type
!= XmlNodeType_Element
&& node_type
!= XmlNodeType_EndElement
) continue;
879 if (FAILED(hr
= IXmlReader_GetLocalName(reader
, &node_name
, NULL
))) return hr
;
880 if (node_type
== XmlNodeType_EndElement
) break;
882 if (!wcscmp(node_name
, L
"Property"))
883 hr
= parse_effect_property(reader
, effect
);
884 else if (!wcscmp(node_name
, L
"Inputs"))
885 hr
= parse_effect_inputs(reader
, effect
);
888 WARN("Unexpected element %s.\n", debugstr_w(node_name
));
889 hr
= parse_effect_skip_element(reader
, depth
);
899 static HRESULT STDMETHODCALLTYPE
d2d_factory_RegisterEffectFromStream(ID2D1Factory3
*iface
,
900 REFCLSID effect_id
, IStream
*property_xml
, const D2D1_PROPERTY_BINDING
*bindings
,
901 UINT32 binding_count
, PD2D1_EFFECT_FACTORY effect_factory
)
903 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
904 struct d2d_effect_registration
*effect
;
909 TRACE("iface %p, effect_id %s, property_xml %p, bindings %p, binding_count %u, effect_factory %p.\n",
910 iface
, debugstr_guid(effect_id
), property_xml
, bindings
, binding_count
, effect_factory
);
912 d2d_factory_init_builtin_effects(factory
);
914 LIST_FOR_EACH_ENTRY_REV(effect
, &factory
->effects
, struct d2d_effect_registration
, entry
)
916 if (IsEqualGUID(effect_id
, &effect
->id
))
918 if (effect
->builtin
) return E_INVALIDARG
;
919 ++effect
->registration_count
;
924 if (FAILED(hr
= CreateXmlReader(&IID_IXmlReader
, (void **)&reader
, NULL
)))
927 if (FAILED(hr
= IXmlReader_SetInput(reader
, (IUnknown
*)property_xml
)))
929 IXmlReader_Release(reader
);
933 if (!(effect
= calloc(1, sizeof(*effect
))))
935 IXmlReader_Release(reader
);
936 return E_OUTOFMEMORY
;
939 hr
= parse_effect_xml(reader
, effect
);
940 IXmlReader_Release(reader
);
943 WARN("Failed to parse effect xml, hr %#lx.\n", hr
);
944 d2d_effect_registration_cleanup(effect
);
948 /* Check required properties. */
949 if (!parse_effect_get_property(effect
, L
"DisplayName")
950 || !parse_effect_get_property(effect
, L
"Author")
951 || !parse_effect_get_property(effect
, L
"Category")
952 || !parse_effect_get_property(effect
, L
"Description")
953 || !parse_effect_get_property(effect
, L
"Inputs"))
955 WARN("Missing required properties.\n");
956 d2d_effect_registration_cleanup(effect
);
960 /* Bind getter and setter. */
961 for (i
= 0; i
< binding_count
; ++i
)
963 struct d2d_effect_property
*property
;
965 if (!(property
= parse_effect_get_property(effect
, bindings
[i
].propertyName
)))
967 WARN("Failed to bind to missing property.\n");
968 d2d_effect_registration_cleanup(effect
);
969 return D2DERR_INVALID_PROPERTY
;
972 property
->get_function
= bindings
[i
].getFunction
;
973 property
->set_function
= bindings
[i
].setFunction
;
976 effect
->registration_count
= 1;
977 effect
->id
= *effect_id
;
978 effect
->factory
= effect_factory
;
979 d2d_effect_properties_add(&effect
->properties
, L
"MinInputs", D2D1_PROPERTY_MIN_INPUTS
,
980 D2D1_PROPERTY_TYPE_UINT32
, L
"1");
981 d2d_effect_properties_add(&effect
->properties
, L
"MaxInputs", D2D1_PROPERTY_MAX_INPUTS
,
982 D2D1_PROPERTY_TYPE_UINT32
, L
"1" /* FIXME */);
983 effect
->default_input_count
= 1;
984 d2d_factory_register_effect(factory
, effect
);
989 static HRESULT STDMETHODCALLTYPE
d2d_factory_RegisterEffectFromString(ID2D1Factory3
*iface
,
990 REFCLSID effect_id
, const WCHAR
*property_xml
, const D2D1_PROPERTY_BINDING
*bindings
,
991 UINT32 binding_count
, PD2D1_EFFECT_FACTORY effect_factory
)
993 static const LARGE_INTEGER zero
;
998 TRACE("iface %p, effect_id %s, property_xml %s, bindings %p, binding_count %u, effect_factory %p.\n",
999 iface
, debugstr_guid(effect_id
), debugstr_w(property_xml
), bindings
, binding_count
, effect_factory
);
1001 if (FAILED(hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stream
)))
1004 size
= sizeof(*property_xml
) * (wcslen(property_xml
) + 1);
1005 if (SUCCEEDED(hr
= IStream_Write(stream
, property_xml
, size
, NULL
)))
1006 hr
= IStream_Seek(stream
, zero
, SEEK_SET
, NULL
);
1009 hr
= ID2D1Factory3_RegisterEffectFromStream(iface
, effect_id
, stream
, bindings
,
1010 binding_count
, effect_factory
);
1012 IStream_Release(stream
);
1016 static HRESULT STDMETHODCALLTYPE
d2d_factory_UnregisterEffect(ID2D1Factory3
*iface
, REFCLSID effect_id
)
1018 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
1019 struct d2d_effect_registration
*effect
;
1021 TRACE("iface %p, effect_id %s.\n", iface
, debugstr_guid(effect_id
));
1023 d2d_factory_init_builtin_effects(factory
);
1025 LIST_FOR_EACH_ENTRY_REV(effect
, &factory
->effects
, struct d2d_effect_registration
, entry
)
1027 if (IsEqualGUID(effect_id
, &effect
->id
))
1029 if (effect
->builtin
) break;
1030 if (!--effect
->registration_count
)
1032 list_remove(&effect
->entry
);
1033 d2d_effect_registration_cleanup(effect
);
1039 return D2DERR_EFFECT_IS_NOT_REGISTERED
;
1042 static HRESULT STDMETHODCALLTYPE
d2d_factory_GetRegisteredEffects(ID2D1Factory3
*iface
,
1043 CLSID
*effects
, UINT32 effect_count
, UINT32
*returned
, UINT32
*registered
)
1045 struct d2d_factory
*factory
= impl_from_ID2D1Factory3(iface
);
1046 struct d2d_effect_registration
*effect
;
1049 TRACE("iface %p, effects %p, effect_count %u, returned %p, registered %p.\n",
1050 iface
, effects
, effect_count
, returned
, registered
);
1052 if (!returned
) returned
= &ret
;
1053 if (!registered
) registered
= ®
;
1058 d2d_factory_init_builtin_effects(factory
);
1060 LIST_FOR_EACH_ENTRY(effect
, &factory
->effects
, struct d2d_effect_registration
, entry
)
1062 if (effects
&& effect_count
)
1064 *effects
= effect
->id
;
1073 if (!effects
) return S_OK
;
1074 return *returned
== *registered
? S_OK
: D2DERR_INSUFFICIENT_BUFFER
;
1077 static HRESULT STDMETHODCALLTYPE
d2d_factory_GetEffectProperties(ID2D1Factory3
*iface
,
1078 REFCLSID effect_id
, ID2D1Properties
**props
)
1080 FIXME("iface %p, effect_id %s, props %p stub!\n", iface
, debugstr_guid(effect_id
), props
);
1085 static HRESULT STDMETHODCALLTYPE
d2d_factory_ID2D1Factory2_CreateDevice(ID2D1Factory3
*iface
, IDXGIDevice
*dxgi_device
,
1086 ID2D1Device1
**device
)
1088 TRACE("iface %p, dxgi_device %p, device %p.\n", iface
, dxgi_device
, device
);
1090 return d2d_factory_create_device(iface
, dxgi_device
, device
);
1093 static HRESULT STDMETHODCALLTYPE
d2d_factory_ID2D1Factory3_CreateDevice(ID2D1Factory3
*iface
, IDXGIDevice
*dxgi_device
,
1094 ID2D1Device2
**device
)
1096 FIXME("iface %p, dxgi_device %p, device %p stub!\n", iface
, dxgi_device
, device
);
1101 static const struct ID2D1Factory3Vtbl d2d_factory_vtbl
=
1103 d2d_factory_QueryInterface
,
1105 d2d_factory_Release
,
1106 d2d_factory_ReloadSystemMetrics
,
1107 d2d_factory_GetDesktopDpi
,
1108 d2d_factory_CreateRectangleGeometry
,
1109 d2d_factory_CreateRoundedRectangleGeometry
,
1110 d2d_factory_CreateEllipseGeometry
,
1111 d2d_factory_CreateGeometryGroup
,
1112 d2d_factory_CreateTransformedGeometry
,
1113 d2d_factory_CreatePathGeometry
,
1114 d2d_factory_CreateStrokeStyle
,
1115 d2d_factory_CreateDrawingStateBlock
,
1116 d2d_factory_CreateWicBitmapRenderTarget
,
1117 d2d_factory_CreateHwndRenderTarget
,
1118 d2d_factory_CreateDxgiSurfaceRenderTarget
,
1119 d2d_factory_CreateDCRenderTarget
,
1120 d2d_factory_CreateDevice
,
1121 d2d_factory_CreateStrokeStyle1
,
1122 d2d_factory_CreatePathGeometry1
,
1123 d2d_factory_CreateDrawingStateBlock1
,
1124 d2d_factory_CreateGdiMetafile
,
1125 d2d_factory_RegisterEffectFromStream
,
1126 d2d_factory_RegisterEffectFromString
,
1127 d2d_factory_UnregisterEffect
,
1128 d2d_factory_GetRegisteredEffects
,
1129 d2d_factory_GetEffectProperties
,
1130 d2d_factory_ID2D1Factory2_CreateDevice
,
1131 d2d_factory_ID2D1Factory3_CreateDevice
,
1134 static HRESULT STDMETHODCALLTYPE
d2d_factory_mt_QueryInterface(ID2D1Multithread
*iface
, REFIID iid
, void **out
)
1136 struct d2d_factory
*factory
= impl_from_ID2D1Multithread(iface
);
1137 return d2d_factory_QueryInterface(&factory
->ID2D1Factory3_iface
, iid
, out
);
1140 static ULONG STDMETHODCALLTYPE
d2d_factory_mt_AddRef(ID2D1Multithread
*iface
)
1142 struct d2d_factory
*factory
= impl_from_ID2D1Multithread(iface
);
1143 return d2d_factory_AddRef(&factory
->ID2D1Factory3_iface
);
1146 static ULONG STDMETHODCALLTYPE
d2d_factory_mt_Release(ID2D1Multithread
*iface
)
1148 struct d2d_factory
*factory
= impl_from_ID2D1Multithread(iface
);
1149 return d2d_factory_Release(&factory
->ID2D1Factory3_iface
);
1152 static BOOL STDMETHODCALLTYPE
d2d_factory_mt_GetMultithreadProtected(ID2D1Multithread
*iface
)
1157 static void STDMETHODCALLTYPE
d2d_factory_mt_Enter(ID2D1Multithread
*iface
)
1159 struct d2d_factory
*factory
= impl_from_ID2D1Multithread(iface
);
1161 TRACE("%p.\n", iface
);
1163 EnterCriticalSection(&factory
->cs
);
1166 static void STDMETHODCALLTYPE
d2d_factory_mt_Leave(ID2D1Multithread
*iface
)
1168 struct d2d_factory
*factory
= impl_from_ID2D1Multithread(iface
);
1170 TRACE("%p.\n", iface
);
1172 LeaveCriticalSection(&factory
->cs
);
1175 static BOOL STDMETHODCALLTYPE
d2d_factory_st_GetMultithreadProtected(ID2D1Multithread
*iface
)
1180 static void STDMETHODCALLTYPE
d2d_factory_st_Enter(ID2D1Multithread
*iface
)
1184 static void STDMETHODCALLTYPE
d2d_factory_st_Leave(ID2D1Multithread
*iface
)
1188 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_vtbl
=
1190 d2d_factory_mt_QueryInterface
,
1191 d2d_factory_mt_AddRef
,
1192 d2d_factory_mt_Release
,
1193 d2d_factory_mt_GetMultithreadProtected
,
1194 d2d_factory_mt_Enter
,
1195 d2d_factory_mt_Leave
,
1198 static const struct ID2D1MultithreadVtbl d2d_factory_multithread_noop_vtbl
=
1200 d2d_factory_mt_QueryInterface
,
1201 d2d_factory_mt_AddRef
,
1202 d2d_factory_mt_Release
,
1203 d2d_factory_st_GetMultithreadProtected
,
1204 d2d_factory_st_Enter
,
1205 d2d_factory_st_Leave
,
1208 static void d2d_factory_init(struct d2d_factory
*factory
, D2D1_FACTORY_TYPE factory_type
,
1209 const D2D1_FACTORY_OPTIONS
*factory_options
)
1211 if (factory_options
&& factory_options
->debugLevel
!= D2D1_DEBUG_LEVEL_NONE
)
1212 WARN("Ignoring debug level %#x.\n", factory_options
->debugLevel
);
1214 factory
->ID2D1Factory3_iface
.lpVtbl
= &d2d_factory_vtbl
;
1215 factory
->ID2D1Multithread_iface
.lpVtbl
= factory_type
== D2D1_FACTORY_TYPE_SINGLE_THREADED
?
1216 &d2d_factory_multithread_noop_vtbl
: &d2d_factory_multithread_vtbl
;
1217 factory
->refcount
= 1;
1218 d2d_factory_reload_sysmetrics(factory
);
1219 list_init(&factory
->effects
);
1220 InitializeCriticalSection(&factory
->cs
);
1221 InitOnceInitialize(&factory
->init_builtins
);
1224 HRESULT WINAPI
D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type
, REFIID iid
,
1225 const D2D1_FACTORY_OPTIONS
*factory_options
, void **factory
)
1227 struct d2d_factory
*object
;
1230 TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n",
1231 factory_type
, debugstr_guid(iid
), factory_options
, factory
);
1233 if (factory_type
!= D2D1_FACTORY_TYPE_SINGLE_THREADED
&&
1234 factory_type
!= D2D1_FACTORY_TYPE_MULTI_THREADED
)
1236 return E_INVALIDARG
;
1239 if (!(object
= calloc(1, sizeof(*object
))))
1240 return E_OUTOFMEMORY
;
1242 d2d_factory_init(object
, factory_type
, factory_options
);
1244 TRACE("Created factory %p.\n", object
);
1246 hr
= ID2D1Factory3_QueryInterface(&object
->ID2D1Factory3_iface
, iid
, factory
);
1247 ID2D1Factory3_Release(&object
->ID2D1Factory3_iface
);
1252 void WINAPI
D2D1MakeRotateMatrix(float angle
, D2D1_POINT_2F center
, D2D1_MATRIX_3X2_F
*matrix
)
1254 float theta
, sin_theta
, cos_theta
;
1256 TRACE("angle %.8e, center %s, matrix %p.\n", angle
, debug_d2d_point_2f(¢er
), matrix
);
1258 theta
= angle
* (M_PI
/ 180.0f
);
1259 sin_theta
= sinf(theta
);
1260 cos_theta
= cosf(theta
);
1262 /* translate(center) * rotate(theta) * translate(-center) */
1263 matrix
->_11
= cos_theta
;
1264 matrix
->_12
= sin_theta
;
1265 matrix
->_21
= -sin_theta
;
1266 matrix
->_22
= cos_theta
;
1267 matrix
->_31
= center
.x
- center
.x
* cos_theta
+ center
.y
* sin_theta
;
1268 matrix
->_32
= center
.y
- center
.x
* sin_theta
- center
.y
* cos_theta
;
1271 void WINAPI
D2D1MakeSkewMatrix(float angle_x
, float angle_y
, D2D1_POINT_2F center
, D2D1_MATRIX_3X2_F
*matrix
)
1275 TRACE("angle_x %.8e, angle_y %.8e, center %s, matrix %p.\n", angle_x
, angle_y
, debug_d2d_point_2f(¢er
), matrix
);
1277 tan_x
= tan(angle_x
* (M_PI
/ 180.0f
));
1278 tan_y
= tan(angle_y
* (M_PI
/ 180.0f
));
1280 /* translate(-center) * skew() * translate(center) */
1282 matrix
->_12
= tan_y
;
1283 matrix
->_21
= tan_x
;
1285 matrix
->_31
= -tan_x
* center
.y
;
1286 matrix
->_32
= -tan_y
* center
.x
;
1289 BOOL WINAPI
D2D1IsMatrixInvertible(const D2D1_MATRIX_3X2_F
*matrix
)
1291 TRACE("matrix %p.\n", matrix
);
1293 return (matrix
->_11
* matrix
->_22
- matrix
->_21
* matrix
->_12
) != 0.0f
;
1296 BOOL WINAPI
D2D1InvertMatrix(D2D1_MATRIX_3X2_F
*matrix
)
1298 D2D1_MATRIX_3X2_F m
= *matrix
;
1300 TRACE("matrix %p.\n", matrix
);
1302 return d2d_matrix_invert(matrix
, &m
);
1305 HRESULT WINAPI
D2D1CreateDevice(IDXGIDevice
*dxgi_device
,
1306 const D2D1_CREATION_PROPERTIES
*properties
, ID2D1Device
**device
)
1308 D2D1_CREATION_PROPERTIES default_properties
= {0};
1309 D2D1_FACTORY_OPTIONS factory_options
;
1310 ID3D11Device
*d3d_device
;
1311 ID2D1Factory1
*factory
;
1314 TRACE("dxgi_device %p, properties %p, device %p.\n", dxgi_device
, properties
, device
);
1318 if (SUCCEEDED(IDXGIDevice_QueryInterface(dxgi_device
, &IID_ID3D11Device
, (void **)&d3d_device
)))
1320 if (!(ID3D11Device_GetCreationFlags(d3d_device
) & D3D11_CREATE_DEVICE_SINGLETHREADED
))
1321 default_properties
.threadingMode
= D2D1_THREADING_MODE_MULTI_THREADED
;
1322 ID3D11Device_Release(d3d_device
);
1324 properties
= &default_properties
;
1327 factory_options
.debugLevel
= properties
->debugLevel
;
1328 if (FAILED(hr
= D2D1CreateFactory(properties
->threadingMode
,
1329 &IID_ID2D1Factory1
, &factory_options
, (void **)&factory
)))
1332 hr
= ID2D1Factory1_CreateDevice(factory
, dxgi_device
, device
);
1333 ID2D1Factory1_Release(factory
);
1337 void WINAPI
D2D1SinCos(float angle
, float *s
, float *c
)
1339 TRACE("angle %.8e, s %p, c %p.\n", angle
, s
, c
);
1345 float WINAPI
D2D1Tan(float angle
)
1347 TRACE("angle %.8e.\n", angle
);
1352 float WINAPI
D2D1Vec3Length(float x
, float y
, float z
)
1354 TRACE("x %.8e, y %.8e, z %.8e.\n", x
, y
, z
);
1356 return sqrtf(x
* x
+ y
* y
+ z
* z
);
1359 /* See IEC 61966-2-1:1999; also described in the EXT_texture_sRGB OpenGL
1360 * extension, among others. */
1361 static float srgb_transfer_function(float x
)
1367 else if (x
<= 0.0031308f
)
1370 return 1.055f
* powf(x
, 1.0f
/ 2.4f
) - 0.055f
;
1373 static float srgb_inverse_transfer_function(float x
)
1379 else if (x
<= 0.04045f
)
1382 return powf((x
+ 0.055f
) / 1.055f
, 2.4f
);
1385 D2D1_COLOR_F WINAPI
D2D1ConvertColorSpace(D2D1_COLOR_SPACE src_colour_space
,
1386 D2D1_COLOR_SPACE dst_colour_space
, const D2D1_COLOR_F
*colour
)
1390 TRACE("src_colour_space %#x, dst_colour_space %#x, colour %s.\n",
1391 src_colour_space
, dst_colour_space
, debug_d2d_color_f(colour
));
1393 if (src_colour_space
== D2D1_COLOR_SPACE_CUSTOM
|| dst_colour_space
== D2D1_COLOR_SPACE_CUSTOM
)
1403 if (src_colour_space
== dst_colour_space
)
1406 if (src_colour_space
== D2D1_COLOR_SPACE_SRGB
&& dst_colour_space
== D2D1_COLOR_SPACE_SCRGB
)
1408 ret
.r
= srgb_inverse_transfer_function(colour
->r
);
1409 ret
.g
= srgb_inverse_transfer_function(colour
->g
);
1410 ret
.b
= srgb_inverse_transfer_function(colour
->b
);
1416 if (src_colour_space
== D2D1_COLOR_SPACE_SCRGB
&& dst_colour_space
== D2D1_COLOR_SPACE_SRGB
)
1418 ret
.r
= srgb_transfer_function(colour
->r
);
1419 ret
.g
= srgb_transfer_function(colour
->g
);
1420 ret
.b
= srgb_transfer_function(colour
->b
);
1426 FIXME("Unhandled conversion from source colour space %#x to destination colour space %#x.\n",
1427 src_colour_space
, dst_colour_space
);
1436 static bool get_config_key_u32(HKEY default_key
, HKEY application_key
, const char *name
, uint32_t *value
)
1441 size
= sizeof(data
);
1442 if (application_key
&& !RegQueryValueExA(application_key
,
1443 name
, 0, &type
, (BYTE
*)&data
, &size
) && type
== REG_DWORD
)
1446 size
= sizeof(data
);
1447 if (default_key
&& !RegQueryValueExA(default_key
,
1448 name
, 0, &type
, (BYTE
*)&data
, &size
) && type
== REG_DWORD
)
1458 static void d2d_settings_init(void)
1460 HKEY default_key
, tmp_key
, application_key
= NULL
;
1461 char buffer
[MAX_PATH
+ 10];
1464 if (RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\Direct2D", &default_key
))
1467 len
= GetModuleFileNameA(0, buffer
, MAX_PATH
);
1468 if (len
&& len
< MAX_PATH
)
1470 char *p
, *appname
= buffer
;
1472 if ((p
= strrchr(appname
, '/')))
1474 if ((p
= strrchr(appname
, '\\')))
1476 strcat(appname
, "\\Direct2D");
1478 if (!RegOpenKeyA(HKEY_CURRENT_USER
, "Software\\Wine\\AppDefaults", &tmp_key
))
1480 if (RegOpenKeyA(tmp_key
, appname
, &application_key
))
1481 application_key
= NULL
;
1482 RegCloseKey(tmp_key
);
1486 if (!default_key
&& !application_key
)
1489 if (get_config_key_u32(default_key
, application_key
, "max_version_factory", &d2d_settings
.max_version_factory
))
1490 ERR_(winediag
)("Limiting maximum Direct2D factory version to %#x.\n", d2d_settings
.max_version_factory
);
1492 if (application_key
)
1493 RegCloseKey(application_key
);
1495 RegCloseKey(default_key
);
1498 BOOL WINAPI
DllMain(HINSTANCE inst
, DWORD reason
, void *reserved
)
1500 if (reason
== DLL_PROCESS_ATTACH
)
1501 d2d_settings_init();