File Index Symbol Index

//---------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// This file is automatically generated. Please do not edit it directly.
//
// File name: D2D1.h
//---------------------------------------------------------------------------
#ifdef _MSC_VER
#pragma once
#endif // #ifdef _MSC_VER
#ifndef _D2D1_H_
#define _D2D1_H_
#ifndef COM_NO_WINDOWS_H
#include <windows.h> #endif // #ifndef COM_NO_WINDOWS_H
#include <unknwn.h> #include <dcommon.h> #include <D2DErr.h> #include <D2DBaseTypes.h>
#include <dxgiformat.h>
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) #include <d3d10_1.h>
#else
#include <d3dcommon.h> #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#ifndef D2D_USE_C_DEFINITIONS
//
// We use the 'C' definitions if C++ is not defined
//
#ifndef __cplusplus
#define D2D_USE_C_DEFINITIONS
#endif
#endif // #ifndef D2D_USE_C_DEFINITIONS
#include <winapifamily.h>
//
// Forward declarations here
//
#pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef
struct
DWRITE_GLYPH_RUN
DWRITE_GLYPH_RUN
;
#ifndef D2D_USE_C_DEFINITIONS
#else
typedef interface ID2D1Factory ID2D1Factory;
typedef interface ID2D1RenderTarget ID2D1RenderTarget;
typedef interface ID2D1BitmapRenderTarget ID2D1BitmapRenderTarget;
typedef interface ID2D1SimplifiedGeometrySink ID2D1SimplifiedGeometrySink;;
typedef interface ID2D1TessellationSink ID2D1TessellationSink;
typedef interface ID2D1Geometry ID2D1Geometry;
typedef interface ID2D1Brush ID2D1Brush;
#endif
#define D2D1_INVALID_TAG ULONGLONG_MAX
#define D2D1_DEFAULT_FLATTENING_TOLERANCE (0.25f)
/// <summary>
/// This defines the superset of interpolation mode supported by D2D APIs
/// and built-in effects
/// </summary>
enum
{
D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR
=
0
,
D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR
=
1
,
D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC
=
2
,
D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR
=
3
,
D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC
=
4
,
D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC
=
5
,
D2D1_INTERPOLATION_MODE_DEFINITION_FANT
=
6
,
D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR
=
7
};
/// <summary>
/// This determines what gamma is used for interpolation/blending.
/// </summary>
typedef
enum
D2D1_GAMMA
{
/// <summary>
/// Colors are manipulated in 2.2 gamma color space.
/// </summary>
D2D1_GAMMA_2_2
=
0
,
/// <summary>
/// Colors are manipulated in 1.0 gamma color space.
/// </summary>
D2D1_GAMMA_1_0
=
1
,
D2D1_GAMMA_FORCE_DWORD
=
0xffffffff
}
D2D1_GAMMA
;
/// <summary>
/// Specifies what the contents are of an opacity mask.
/// </summary>
typedef
enum
D2D1_OPACITY_MASK_CONTENT
{
/// <summary>
/// The mask contains geometries or bitmaps.
/// </summary>
D2D1_OPACITY_MASK_CONTENT_GRAPHICS
=
0
,
/// <summary>
/// The mask contains text rendered using one of the natural text modes.
/// </summary>
D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL
=
1
,
/// <summary>
/// The mask contains text rendered using one of the GDI compatible text modes.
/// </summary>
D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE
=
2
,
D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD
=
0xffffffff
}
D2D1_OPACITY_MASK_CONTENT
;
/// <summary>
/// Enum which describes how to sample from a source outside its base tile.
/// </summary>
typedef
enum
D2D1_EXTEND_MODE
{
/// <summary>
/// Extend the edges of the source out by clamping sample points outside the source
/// to the edges.
/// </summary>
D2D1_EXTEND_MODE_CLAMP
=
0
,
/// <summary>
/// The base tile is drawn untransformed and the remainder are filled by repeating
/// the base tile.
/// </summary>
D2D1_EXTEND_MODE_WRAP
=
1
,
/// <summary>
/// The same as wrap, but alternate tiles are flipped The base tile is drawn
/// untransformed.
/// </summary>
D2D1_EXTEND_MODE_MIRROR
=
2
,
D2D1_EXTEND_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_EXTEND_MODE
;
/// <summary>
/// Enum which describes the manner in which we render edges of non-text primitives.
/// </summary>
typedef
enum
D2D1_ANTIALIAS_MODE
{
/// <summary>
/// The edges of each primitive are antialiased sequentially.
/// </summary>
D2D1_ANTIALIAS_MODE_PER_PRIMITIVE
=
0
,
/// <summary>
/// Each pixel is rendered if its pixel center is contained by the geometry.
/// </summary>
D2D1_ANTIALIAS_MODE_ALIASED
=
1
,
D2D1_ANTIALIAS_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_ANTIALIAS_MODE
;
/// <summary>
/// Describes the antialiasing mode used for drawing text.
/// </summary>
typedef
enum
D2D1_TEXT_ANTIALIAS_MODE
{
/// <summary>
/// Render text using the current system setting.
/// </summary>
D2D1_TEXT_ANTIALIAS_MODE_DEFAULT
=
0
,
/// <summary>
/// Render text using ClearType.
/// </summary>
D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE
=
1
,
/// <summary>
/// Render text using gray-scale.
/// </summary>
D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE
=
2
,
/// <summary>
/// Render text aliased.
/// </summary>
D2D1_TEXT_ANTIALIAS_MODE_ALIASED
=
3
,
D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_TEXT_ANTIALIAS_MODE
;
/// <summary>
/// Specifies the algorithm that is used when images are scaled or rotated. Note
/// Starting in Windows 8, more interpolations modes are available. See
/// D2D1_INTERPOLATION_MODE for more info.
/// </summary>
typedef
enum
D2D1_BITMAP_INTERPOLATION_MODE
{
/// <summary>
/// Nearest Neighbor filtering. Also known as nearest pixel or nearest point
/// sampling.
/// </summary>
D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR
=
D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR
,
/// <summary>
/// Linear filtering.
/// </summary>
D2D1_BITMAP_INTERPOLATION_MODE_LINEAR
=
D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR
,
D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_BITMAP_INTERPOLATION_MODE
;
/// <summary>
/// Modifications made to the draw text call that influence how the text is
/// rendered.
/// </summary>
typedef
enum
D2D1_DRAW_TEXT_OPTIONS
{
/// <summary>
/// Do not snap the baseline of the text vertically.
/// </summary>
D2D1_DRAW_TEXT_OPTIONS_NO_SNAP
=
0x00000001
,
/// <summary>
/// Clip the text to the content bounds.
/// </summary>
D2D1_DRAW_TEXT_OPTIONS_CLIP
=
0x00000002
,
/// <summary>
/// Render color versions of glyphs if defined by the font.
/// </summary>
D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT
=
0x00000004
,
/// <summary>
/// Bitmap origins of color glyph bitmaps are not snapped.
/// </summary>
D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING
=
0x00000008
,
D2D1_DRAW_TEXT_OPTIONS_NONE
=
0x00000000
,
D2D1_DRAW_TEXT_OPTIONS_FORCE_DWORD
=
0xffffffff
}
D2D1_DRAW_TEXT_OPTIONS
;
typedef
D2D_POINT_2U
D2D1_POINT_2U
;
typedef
D2D_POINT_2F
D2D1_POINT_2F
;
typedef
D2D_RECT_F
D2D1_RECT_F
;
typedef
D2D_RECT_U
D2D1_RECT_U
;
typedef
D2D_SIZE_F
D2D1_SIZE_F
;
typedef
D2D_SIZE_U
D2D1_SIZE_U
;
typedef
D2D_COLOR_F
D2D1_COLOR_F
;
typedef
D2D_MATRIX_3X2_F
D2D1_MATRIX_3X2_F
;
typedef
UINT64
D2D1_TAG
;
/// <summary>
/// Describes the pixel format and dpi of a bitmap.
/// </summary>
typedef
struct
D2D1_BITMAP_PROPERTIES
{
D2D1_PIXEL_FORMAT
pixelFormat
;
FLOAT
dpiX
;
FLOAT
dpiY
; }
D2D1_BITMAP_PROPERTIES
;
/// <summary>
/// Contains the position and color of a gradient stop.
/// </summary>
typedef
struct
D2D1_GRADIENT_STOP
{
FLOAT
position
;
D2D1_COLOR_F
color
; }
D2D1_GRADIENT_STOP
;
/// <summary>
/// Describes the opacity and transformation of a brush.
/// </summary>
typedef
struct
D2D1_BRUSH_PROPERTIES
{
FLOAT
opacity
;
D2D1_MATRIX_3X2_F
transform
; }
D2D1_BRUSH_PROPERTIES
;
/// <summary>
/// Describes the extend modes and the interpolation mode of an ID2D1BitmapBrush.
/// </summary>
typedef
struct
D2D1_BITMAP_BRUSH_PROPERTIES
{
D2D1_EXTEND_MODE
extendModeX
;
D2D1_EXTEND_MODE
extendModeY
;
D2D1_BITMAP_INTERPOLATION_MODE
interpolationMode
; }
D2D1_BITMAP_BRUSH_PROPERTIES
;
/// <summary>
/// Contains the starting point and endpoint of the gradient axis for an
/// ID2D1LinearGradientBrush.
/// </summary>
typedef
struct
D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES
{
D2D1_POINT_2F
startPoint
;
D2D1_POINT_2F
endPoint
; }
D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES
;
/// <summary>
/// Contains the gradient origin offset and the size and position of the gradient
/// ellipse for an ID2D1RadialGradientBrush.
/// </summary>
typedef
struct
D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES
{
D2D1_POINT_2F
center
;
D2D1_POINT_2F
gradientOriginOffset
;
FLOAT
radiusX
;
FLOAT
radiusY
; }
D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES
;
/// <summary>
/// Differentiates which of the two possible arcs could match the given arc
/// parameters.
/// </summary>
typedef
enum
D2D1_ARC_SIZE
{
D2D1_ARC_SIZE_SMALL
=
0
,
D2D1_ARC_SIZE_LARGE
=
1
,
D2D1_ARC_SIZE_FORCE_DWORD
=
0xffffffff
}
D2D1_ARC_SIZE
;
/// <summary>
/// Enum which describes the drawing of the ends of a line.
/// </summary>
typedef
enum
D2D1_CAP_STYLE
{
/// <summary>
/// Flat line cap.
/// </summary>
D2D1_CAP_STYLE_FLAT
=
0
,
/// <summary>
/// Square line cap.
/// </summary>
D2D1_CAP_STYLE_SQUARE
=
1
,
/// <summary>
/// Round line cap.
/// </summary>
D2D1_CAP_STYLE_ROUND
=
2
,
/// <summary>
/// Triangle line cap.
/// </summary>
D2D1_CAP_STYLE_TRIANGLE
=
3
,
D2D1_CAP_STYLE_FORCE_DWORD
=
0xffffffff
}
D2D1_CAP_STYLE
;
/// <summary>
/// Describes the sequence of dashes and gaps in a stroke.
/// </summary>
typedef
enum
D2D1_DASH_STYLE
{
D2D1_DASH_STYLE_SOLID
=
0
,
D2D1_DASH_STYLE_DASH
=
1
,
D2D1_DASH_STYLE_DOT
=
2
,
D2D1_DASH_STYLE_DASH_DOT
=
3
,
D2D1_DASH_STYLE_DASH_DOT_DOT
=
4
,
D2D1_DASH_STYLE_CUSTOM
=
5
,
D2D1_DASH_STYLE_FORCE_DWORD
=
0xffffffff
}
D2D1_DASH_STYLE
;
/// <summary>
/// Enum which describes the drawing of the corners on the line.
/// </summary>
typedef
enum
D2D1_LINE_JOIN
{
/// <summary>
/// Miter join.
/// </summary>
D2D1_LINE_JOIN_MITER
=
0
,
/// <summary>
/// Bevel join.
/// </summary>
D2D1_LINE_JOIN_BEVEL
=
1
,
/// <summary>
/// Round join.
/// </summary>
D2D1_LINE_JOIN_ROUND
=
2
,
/// <summary>
/// Miter/Bevel join.
/// </summary>
D2D1_LINE_JOIN_MITER_OR_BEVEL
=
3
,
D2D1_LINE_JOIN_FORCE_DWORD
=
0xffffffff
}
D2D1_LINE_JOIN
;
/// <summary>
/// This enumeration describes the type of combine operation to be performed.
/// </summary>
typedef
enum
D2D1_COMBINE_MODE
{
/// <summary>
/// Produce a geometry representing the set of points contained in either the first
/// or the second geometry.
/// </summary>
D2D1_COMBINE_MODE_UNION
=
0
,
/// <summary>
/// Produce a geometry representing the set of points common to the first and the
/// second geometries.
/// </summary>
D2D1_COMBINE_MODE_INTERSECT
=
1
,
/// <summary>
/// Produce a geometry representing the set of points contained in the first
/// geometry or the second geometry, but not both.
/// </summary>
D2D1_COMBINE_MODE_XOR
=
2
,
/// <summary>
/// Produce a geometry representing the set of points contained in the first
/// geometry but not the second geometry.
/// </summary>
D2D1_COMBINE_MODE_EXCLUDE
=
3
,
D2D1_COMBINE_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_COMBINE_MODE
;
/// <summary>
/// Describes how one geometry object is spatially related to another geometry
/// object.
/// </summary>
typedef
enum
D2D1_GEOMETRY_RELATION
{
/// <summary>
/// The relation between the geometries couldn't be determined. This value is never
/// returned by any D2D method.
/// </summary>
D2D1_GEOMETRY_RELATION_UNKNOWN
=
0
,
/// <summary>
/// The two geometries do not intersect at all.
/// </summary>
D2D1_GEOMETRY_RELATION_DISJOINT
=
1
,
/// <summary>
/// The passed in geometry is entirely contained by the object.
/// </summary>
D2D1_GEOMETRY_RELATION_IS_CONTAINED
=
2
,
/// <summary>
/// The object entirely contains the passed in geometry.
/// </summary>
D2D1_GEOMETRY_RELATION_CONTAINS
=
3
,
/// <summary>
/// The two geometries overlap but neither completely contains the other.
/// </summary>
D2D1_GEOMETRY_RELATION_OVERLAP
=
4
,
D2D1_GEOMETRY_RELATION_FORCE_DWORD
=
0xffffffff
}
D2D1_GEOMETRY_RELATION
;
/// <summary>
/// Specifies how simple the output of a simplified geometry sink should be.
/// </summary>
typedef
enum
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
{
D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES
=
0
,
D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES
=
1
,
D2D1_GEOMETRY_SIMPLIFICATION_OPTION_FORCE_DWORD
=
0xffffffff
}
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
;
/// <summary>
/// Indicates whether the given figure is filled or hollow.
/// </summary>
typedef
enum
D2D1_FIGURE_BEGIN
{
D2D1_FIGURE_BEGIN_FILLED
=
0
,
D2D1_FIGURE_BEGIN_HOLLOW
=
1
,
D2D1_FIGURE_BEGIN_FORCE_DWORD
=
0xffffffff
}
D2D1_FIGURE_BEGIN
;
/// <summary>
/// Indicates whether the figure is open or closed on its end point.
/// </summary>
typedef
enum
D2D1_FIGURE_END
{
D2D1_FIGURE_END_OPEN
=
0
,
D2D1_FIGURE_END_CLOSED
=
1
,
D2D1_FIGURE_END_FORCE_DWORD
=
0xffffffff
}
D2D1_FIGURE_END
;
/// <summary>
/// Describes a cubic bezier in a path.
/// </summary>
typedef
struct
D2D1_BEZIER_SEGMENT
{
D2D1_POINT_2F
point1
;
D2D1_POINT_2F
point2
;
D2D1_POINT_2F
point3
; }
D2D1_BEZIER_SEGMENT
;
/// <summary>
/// Describes a triangle.
/// </summary>
typedef
struct
D2D1_TRIANGLE
{
D2D1_POINT_2F
point1
;
D2D1_POINT_2F
point2
;
D2D1_POINT_2F
point3
; }
D2D1_TRIANGLE
;
/// <summary>
/// Indicates whether the given segment should be stroked, or, if the join between
/// this segment and the previous one should be smooth.
/// </summary>
typedef
enum
D2D1_PATH_SEGMENT
{
D2D1_PATH_SEGMENT_NONE
=
0x00000000
,
D2D1_PATH_SEGMENT_FORCE_UNSTROKED
=
0x00000001
,
D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN
=
0x00000002
,
D2D1_PATH_SEGMENT_FORCE_DWORD
=
0xffffffff
}
D2D1_PATH_SEGMENT
;
/// <summary>
/// Defines the direction that an elliptical arc is drawn.
/// </summary>
typedef
enum
D2D1_SWEEP_DIRECTION
{
D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE
=
0
,
D2D1_SWEEP_DIRECTION_CLOCKWISE
=
1
,
D2D1_SWEEP_DIRECTION_FORCE_DWORD
=
0xffffffff
}
D2D1_SWEEP_DIRECTION
;
/// <summary>
/// Specifies how the intersecting areas of geometries or figures are combined to
/// form the area of the composite geometry.
/// </summary>
typedef
enum
D2D1_FILL_MODE
{
D2D1_FILL_MODE_ALTERNATE
=
0
,
D2D1_FILL_MODE_WINDING
=
1
,
D2D1_FILL_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_FILL_MODE
;
/// <summary>
/// Describes an arc that is defined as part of a path.
/// </summary>
typedef
struct
D2D1_ARC_SEGMENT
{
D2D1_POINT_2F
point
;
D2D1_SIZE_F
size
;
FLOAT
rotationAngle
;
D2D1_SWEEP_DIRECTION
sweepDirection
;
D2D1_ARC_SIZE
arcSize
; }
D2D1_ARC_SEGMENT
;
/// <summary>
/// Contains the control point and end point for a quadratic Bezier segment.
/// </summary>
typedef
struct
D2D1_QUADRATIC_BEZIER_SEGMENT
{
D2D1_POINT_2F
point1
;
D2D1_POINT_2F
point2
; }
D2D1_QUADRATIC_BEZIER_SEGMENT
;
/// <summary>
/// Contains the center point, x-radius, and y-radius of an ellipse.
/// </summary>
typedef
struct
D2D1_ELLIPSE
{
D2D1_POINT_2F
point
;
FLOAT
radiusX
;
FLOAT
radiusY
; }
D2D1_ELLIPSE
;
/// <summary>
/// Contains the dimensions and corner radii of a rounded rectangle.
/// </summary>
typedef
struct
D2D1_ROUNDED_RECT
{
D2D1_RECT_F
rect
;
FLOAT
radiusX
;
FLOAT
radiusY
; }
D2D1_ROUNDED_RECT
;
/// <summary>
/// Properties, aside from the width, that allow geometric penning to be specified.
/// </summary>
typedef
struct
D2D1_STROKE_STYLE_PROPERTIES
{
D2D1_CAP_STYLE
startCap
;
D2D1_CAP_STYLE
endCap
;
D2D1_CAP_STYLE
dashCap
;
D2D1_LINE_JOIN
lineJoin
;
FLOAT
miterLimit
;
D2D1_DASH_STYLE
dashStyle
;
FLOAT
dashOffset
; }
D2D1_STROKE_STYLE_PROPERTIES
;
/// <summary>
/// Specified options that can be applied when a layer resource is applied to create
/// a layer.
/// </summary>
typedef
enum
D2D1_LAYER_OPTIONS
{
D2D1_LAYER_OPTIONS_NONE
=
0x00000000
,
/// <summary>
/// The layer will render correctly for ClearType text. If the render target was set
/// to ClearType previously, the layer will continue to render ClearType. If the
/// render target was set to ClearType and this option is not specified, the render
/// target will be set to render gray-scale until the layer is popped. The caller
/// can override this default by calling SetTextAntialiasMode while within the
/// layer. This flag is slightly slower than the default.
/// </summary>
D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE
=
0x00000001
,
D2D1_LAYER_OPTIONS_FORCE_DWORD
=
0xffffffff
}
D2D1_LAYER_OPTIONS
;
/// <summary>
/// Contains the content bounds, mask information, opacity settings, and other
/// options for a layer resource.
/// </summary>
typedef
struct
D2D1_LAYER_PARAMETERS
{
/// <summary>
/// The rectangular clip that will be applied to the layer. The clip is affected by
/// the world transform. Content outside of the content bounds will not render.
/// </summary>
D2D1_RECT_F
contentBounds
;
/// <summary>
/// A general mask that can be optionally applied to the content. Content not inside
/// the fill of the mask will not be rendered.
/// </summary>
/// <summary>
/// Specifies whether the mask should be aliased or antialiased.
/// </summary>
D2D1_ANTIALIAS_MODE
maskAntialiasMode
;
/// <summary>
/// An additional transform that may be applied to the mask in addition to the
/// current world transform.
/// </summary>
D2D1_MATRIX_3X2_F
maskTransform
;
/// <summary>
/// The opacity with which all of the content in the layer will be blended back to
/// the target when the layer is popped.
/// </summary>
FLOAT
opacity
;
/// <summary>
/// An additional brush that can be applied to the layer. Only the opacity channel
/// is sampled from this brush and multiplied both with the layer content and the
/// over-all layer opacity.
/// </summary>
/// <summary>
/// Specifies if ClearType will be rendered into the layer.
/// </summary>
D2D1_LAYER_OPTIONS
layerOptions
; }
D2D1_LAYER_PARAMETERS
;
/// <summary>
/// Describes whether a window is occluded.
/// </summary>
typedef
enum
D2D1_WINDOW_STATE
{
D2D1_WINDOW_STATE_NONE
=
0x0000000
,
D2D1_WINDOW_STATE_OCCLUDED
=
0x0000001
,
D2D1_WINDOW_STATE_FORCE_DWORD
=
0xffffffff
}
D2D1_WINDOW_STATE
;
/// <summary>
/// Describes whether a render target uses hardware or software rendering, or if
/// Direct2D should select the rendering mode.
/// </summary>
typedef
enum
D2D1_RENDER_TARGET_TYPE
{
/// <summary>
/// D2D is free to choose the render target type for the caller.
/// </summary>
D2D1_RENDER_TARGET_TYPE_DEFAULT
=
0
,
/// <summary>
/// The render target will render using the CPU.
/// </summary>
D2D1_RENDER_TARGET_TYPE_SOFTWARE
=
1
,
/// <summary>
/// The render target will render using the GPU.
/// </summary>
D2D1_RENDER_TARGET_TYPE_HARDWARE
=
2
,
D2D1_RENDER_TARGET_TYPE_FORCE_DWORD
=
0xffffffff
}
D2D1_RENDER_TARGET_TYPE
;
/// <summary>
/// Describes the minimum DirectX support required for hardware rendering by a
/// render target.
/// </summary>
typedef
enum
D2D1_FEATURE_LEVEL
{
/// <summary>
/// The caller does not require a particular underlying D3D device level.
/// </summary>
D2D1_FEATURE_LEVEL_DEFAULT
=
0
,
/// <summary>
/// The D3D device level is DX9 compatible.
/// </summary>
D2D1_FEATURE_LEVEL_9
=
D3D_FEATURE_LEVEL_9_1
,
/// <summary>
/// The D3D device level is DX10 compatible.
/// </summary>
D2D1_FEATURE_LEVEL_10
=
D3D_FEATURE_LEVEL_10_0
,
D2D1_FEATURE_LEVEL_FORCE_DWORD
=
0xffffffff
}
D2D1_FEATURE_LEVEL
;
/// <summary>
/// Describes how a render target is remoted and whether it should be
/// GDI-compatible. This enumeration allows a bitwise combination of its member
/// values.
/// </summary>
typedef
enum
D2D1_RENDER_TARGET_USAGE
{
D2D1_RENDER_TARGET_USAGE_NONE
=
0x00000000
,
/// <summary>
/// Rendering will occur locally, if a terminal-services session is established, the
/// bitmap updates will be sent to the terminal services client.
/// </summary>
D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING
=
0x00000001
,
/// <summary>
/// The render target will allow a call to GetDC on the ID2D1GdiInteropRenderTarget
/// interface. Rendering will also occur locally.
/// </summary>
D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE
=
0x00000002
,
D2D1_RENDER_TARGET_USAGE_FORCE_DWORD
=
0xffffffff
}
D2D1_RENDER_TARGET_USAGE
;
/// <summary>
/// Describes how present should behave.
/// </summary>
typedef
enum
D2D1_PRESENT_OPTIONS
{
D2D1_PRESENT_OPTIONS_NONE
=
0x00000000
,
/// <summary>
/// Keep the target contents intact through present.
/// </summary>
D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS
=
0x00000001
,
/// <summary>
/// Do not wait for display refresh to commit changes to display.
/// </summary>
D2D1_PRESENT_OPTIONS_IMMEDIATELY
=
0x00000002
,
D2D1_PRESENT_OPTIONS_FORCE_DWORD
=
0xffffffff
}
D2D1_PRESENT_OPTIONS
;
/// <summary>
/// Contains rendering options (hardware or software), pixel format, DPI
/// information, remoting options, and Direct3D support requirements for a render
/// target.
/// </summary>
typedef
struct
D2D1_RENDER_TARGET_PROPERTIES
{
D2D1_RENDER_TARGET_TYPE
type
;
D2D1_PIXEL_FORMAT
pixelFormat
;
FLOAT
dpiX
;
FLOAT
dpiY
;
D2D1_RENDER_TARGET_USAGE
usage
;
D2D1_FEATURE_LEVEL
minLevel
; }
D2D1_RENDER_TARGET_PROPERTIES
;
/// <summary>
/// Contains the HWND, pixel size, and presentation options for an
/// ID2D1HwndRenderTarget.
/// </summary>
typedef
struct
D2D1_HWND_RENDER_TARGET_PROPERTIES
{
HWND
hwnd
;
D2D1_SIZE_U
pixelSize
;
D2D1_PRESENT_OPTIONS
presentOptions
; }
D2D1_HWND_RENDER_TARGET_PROPERTIES
;
/// <summary>
/// Specifies additional features supportable by a compatible render target when it
/// is created. This enumeration allows a bitwise combination of its member values.
/// </summary>
typedef
enum
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS
{
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE
=
0x00000000
,
/// <summary>
/// The compatible render target will allow a call to GetDC on the
/// ID2D1GdiInteropRenderTarget interface. This can be specified even if the parent
/// render target is not GDI compatible.
/// </summary>
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE
=
0x00000001
,
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_FORCE_DWORD
=
0xffffffff
}
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS
;
/// <summary>
/// Allows the drawing state to be atomically created. This also specifies the
/// drawing state that is saved into an IDrawingStateBlock object.
/// </summary>
typedef
struct
D2D1_DRAWING_STATE_DESCRIPTION
{
D2D1_ANTIALIAS_MODE
antialiasMode
;
D2D1_TEXT_ANTIALIAS_MODE
textAntialiasMode
;
D2D1_TAG
tag1
;
D2D1_TAG
tag2
;
D2D1_MATRIX_3X2_F
transform
; }
D2D1_DRAWING_STATE_DESCRIPTION
;
/// <summary>
/// Specifies how a device context is initialized for GDI rendering when it is
/// retrieved from the render target.
/// </summary>
typedef
enum
D2D1_DC_INITIALIZE_MODE
{
/// <summary>
/// The contents of the D2D render target will be copied to the DC.
/// </summary>
D2D1_DC_INITIALIZE_MODE_COPY
=
0
,
/// <summary>
/// The contents of the DC will be cleared.
/// </summary>
D2D1_DC_INITIALIZE_MODE_CLEAR
=
1
,
D2D1_DC_INITIALIZE_MODE_FORCE_DWORD
=
0xffffffff
}
D2D1_DC_INITIALIZE_MODE
;
/// <summary>
/// Indicates the debug level to be output by the debug layer.
/// </summary>
typedef
enum
D2D1_DEBUG_LEVEL
{
D2D1_DEBUG_LEVEL_NONE
=
0
,
D2D1_DEBUG_LEVEL_ERROR
=
1
,
D2D1_DEBUG_LEVEL_WARNING
=
2
,
D2D1_DEBUG_LEVEL_INFORMATION
=
3
,
D2D1_DEBUG_LEVEL_FORCE_DWORD
=
0xffffffff
}
D2D1_DEBUG_LEVEL
;
/// <summary>
/// Specifies the threading model of the created factory and all of its derived
/// resources.
/// </summary>
typedef
enum
D2D1_FACTORY_TYPE
{
/// <summary>
/// The resulting factory and derived resources may only be invoked serially.
/// Reference counts on resources are interlocked, however, resource and render
/// target state is not protected from multi-threaded access.
/// </summary>
D2D1_FACTORY_TYPE_SINGLE_THREADED
=
0
,
/// <summary>
/// The resulting factory may be invoked from multiple threads. Returned resources
/// use interlocked reference counting and their state is protected.
/// </summary>
D2D1_FACTORY_TYPE_MULTI_THREADED
=
1
,
D2D1_FACTORY_TYPE_FORCE_DWORD
=
0xffffffff
}
D2D1_FACTORY_TYPE
;
/// <summary>
/// Allows additional parameters for factory creation.
/// </summary>
typedef
struct
D2D1_FACTORY_OPTIONS
{
/// <summary>
/// Requests a certain level of debugging information from the debug layer. This
/// parameter is ignored if the debug layer DLL is not present.
/// </summary>
D2D1_DEBUG_LEVEL
debugLevel
; }
D2D1_FACTORY_OPTIONS
;
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion #pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion #pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
#ifndef D2D_USE_C_DEFINITIONS
#pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
/// <summary>
/// The root interface for all resources in D2D.
/// </summary>
{
/// <summary>
/// Retrieve the factory associated with this resource.
/// </summary>
};
// interface ID2D1Resource
/// <summary>
/// Represents a producer of pixels that can fill an arbitrary 2D plane.
/// </summary>
{ };
// interface ID2D1Image
/// <summary>
/// Root bitmap resource, linearly scaled on a draw call.
/// </summary>
{
/// <summary>
/// Returns the size of the bitmap in resolution independent units.
/// </summary>
/// <summary>
/// Returns the size of the bitmap in resolution dependent units, (pixels).
/// </summary>
/// <summary>
/// Retrieve the format of the bitmap.
/// </summary>
/// <summary>
/// Return the DPI of the bitmap.
/// </summary>
UINT32
pitch
};
// interface ID2D1Bitmap
/// <summary>
/// Represents an collection of gradient stops that can then be the source resource
/// for either a linear or radial gradient brush.
/// </summary>
{
/// <summary>
/// Returns the number of stops in the gradient.
/// </summary>
/// <summary>
/// Copies the gradient stops from the collection into the caller's interface. The
/// returned colors have straight alpha.
/// </summary>
UINT32
gradientStopsCount
/// <summary>
/// Returns whether the interpolation occurs with 1.0 or 2.2 gamma.
/// </summary>
};
// interface ID2D1GradientStopCollection
/// <summary>
/// The root brush interface. All brushes can be used to fill or pen a geometry.
/// </summary>
{
/// <summary>
/// Sets the opacity for when the brush is drawn over the entire fill of the brush.
/// </summary>
FLOAT
opacity
/// <summary>
/// Sets the transform that applies to everything drawn by the brush.
/// </summary>
void
SetTransform
( ) {
SetTransform
(&
transform
); } };
// interface ID2D1Brush
/// <summary>
/// A bitmap brush allows a bitmap to be used to fill a geometry.
/// </summary>
{
/// <summary>
/// Sets how the bitmap is to be treated outside of its natural extent on the X
/// axis.
/// </summary>
D2D1_EXTEND_MODE
extendModeX
/// <summary>
/// Sets how the bitmap is to be treated outside of its natural extent on the X
/// axis.
/// </summary>
D2D1_EXTEND_MODE
extendModeY
/// <summary>
/// Sets the interpolation mode used when this brush is used.
/// </summary>
D2D1_BITMAP_INTERPOLATION_MODE
interpolationMode
/// <summary>
/// Sets the bitmap associated as the source of this brush.
/// </summary>
};
// interface ID2D1BitmapBrush
/// <summary>
/// Paints an area with a solid color.
/// </summary>
{
void
SetColor
( ) {
SetColor
(&
color
); } };
// interface ID2D1SolidColorBrush
/// <summary>
/// Paints an area with a linear gradient.
/// </summary>
{
D2D1_POINT_2F
startPoint
/// <summary>
/// Sets the end point of the gradient in local coordinate space. This is not
/// influenced by the geometry being filled.
/// </summary>
D2D1_POINT_2F
endPoint
};
// interface ID2D1LinearGradientBrush
/// <summary>
/// Paints an area with a radial gradient.
/// </summary>
{
/// <summary>
/// Sets the center of the radial gradient. This will be in local coordinates and
/// will not depend on the geometry being filled.
/// </summary>
D2D1_POINT_2F
center
/// <summary>
/// Sets offset of the origin relative to the radial gradient center.
/// </summary>
D2D1_POINT_2F
gradientOriginOffset
FLOAT
radiusX
FLOAT
radiusY
};
// interface ID2D1RadialGradientBrush
/// <summary>
/// Resource interface that holds pen style properties.
/// </summary>
{
/// <summary>
/// Returns the dashes from the object into a user allocated array. The user must
/// call GetDashesCount to retrieve the required size.
/// </summary>
UINT32
dashesCount
};
// interface ID2D1StrokeStyle
/// <summary>
/// Represents a geometry resource and defines a set of helper methods for
/// manipulating and measuring geometric shapes. Interfaces that inherit from
/// ID2D1Geometry define specific shapes.
/// </summary>
{
/// <summary>
/// Retrieve the bounds of the geometry, with an optional applied transform.
/// </summary>
/// <summary>
/// Get the bounds of the corresponding geometry after it has been widened or have
/// an optional pen style applied.
/// </summary>
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Checks to see whether the corresponding penned and widened geometry contains the
/// given point.
/// </summary>
D2D1_POINT_2F
point
,
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Test whether the given fill of this geometry would contain this point.
/// </summary>
D2D1_POINT_2F
point
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Compare how one geometry intersects or contains another geometry.
/// </summary>
FLOAT
flatteningTolerance
,
/// <summary>
/// Converts a geometry to a simplified geometry that has arcs and quadratic beziers
/// removed.
/// </summary>
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
simplificationOption
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Tessellates a geometry into triangles.
/// </summary>
FLOAT
flatteningTolerance
,
/// <summary>
/// Performs a combine operation between the two geometries to produce a resulting
/// geometry.
/// </summary>
D2D1_COMBINE_MODE
combineMode
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Computes the outline of the geometry. The result is written back into a
/// simplified geometry sink.
/// </summary>
FLOAT
flatteningTolerance
,
/// <summary>
/// Computes the area of the geometry.
/// </summary>
FLOAT
flatteningTolerance
,
/// <summary>
/// Computes the length of the geometry.
/// </summary>
FLOAT
flatteningTolerance
,
/// <summary>
/// Computes the point and tangent a given distance along the path.
/// </summary>
FLOAT
length
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Get the geometry and widen it as well as apply an optional pen style.
/// </summary>
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
,
/// <summary>
/// Retrieve the bounds of the geometry, with an optional applied transform.
/// </summary>
HRESULT
GetBounds
( {
return
GetBounds
(&
worldTransform
,
bounds
); }
/// <summary>
/// Get the bounds of the corresponding geometry after it has been widened or have
/// an optional pen style applied.
/// </summary>
HRESULT
GetWidenedBounds
(
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
, {
return
GetWidenedBounds
(
strokeWidth
,
strokeStyle
, &
worldTransform
,
flatteningTolerance
,
bounds
); }
/// <summary>
/// Get the bounds of the corresponding geometry after it has been widened or have
/// an optional pen style applied.
/// </summary>
HRESULT
GetWidenedBounds
(
FLOAT
strokeWidth
, { }
/// <summary>
/// Get the bounds of the corresponding geometry after it has been widened or have
/// an optional pen style applied.
/// </summary>
HRESULT
GetWidenedBounds
(
FLOAT
strokeWidth
, { }
HRESULT
StrokeContainsPoint
(
D2D1_POINT_2F
point
,
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
, {
return
StrokeContainsPoint
(
point
,
strokeWidth
,
strokeStyle
, &
worldTransform
,
flatteningTolerance
,
contains
); }
/// <summary>
/// Checks to see whether the corresponding penned and widened geometry contains the
/// given point.
/// </summary>
HRESULT
StrokeContainsPoint
(
D2D1_POINT_2F
point
,
FLOAT
strokeWidth
, { }
HRESULT
StrokeContainsPoint
(
D2D1_POINT_2F
point
,
FLOAT
strokeWidth
, { }
HRESULT
FillContainsPoint
(
D2D1_POINT_2F
point
,
FLOAT
flatteningTolerance
, {
return
FillContainsPoint
(
point
, &
worldTransform
,
flatteningTolerance
,
contains
); }
/// <summary>
/// Test whether the given fill of this geometry would contain this point.
/// </summary>
HRESULT
FillContainsPoint
(
D2D1_POINT_2F
point
, { }
HRESULT
FillContainsPoint
(
D2D1_POINT_2F
point
, { }
/// <summary>
/// Compare how one geometry intersects or contains another geometry.
/// </summary>
HRESULT
CompareWithGeometry
(
FLOAT
flatteningTolerance
, {
return
CompareWithGeometry
(
inputGeometry
, &
inputGeometryTransform
,
flatteningTolerance
,
relation
); }
/// <summary>
/// Compare how one geometry intersects or contains another geometry.
/// </summary>
HRESULT
CompareWithGeometry
( { }
/// <summary>
/// Compare how one geometry intersects or contains another geometry.
/// </summary>
HRESULT
CompareWithGeometry
( { }
/// <summary>
/// Converts a geometry to a simplified geometry that has arcs and quadratic beziers
/// removed.
/// </summary>
HRESULT
Simplify
(
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
simplificationOption
,
FLOAT
flatteningTolerance
, {
return
Simplify
(
simplificationOption
, &
worldTransform
,
flatteningTolerance
,
geometrySink
); }
/// <summary>
/// Converts a geometry to a simplified geometry that has arcs and quadratic beziers
/// removed.
/// </summary>
HRESULT
Simplify
(
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
simplificationOption
, { }
/// <summary>
/// Converts a geometry to a simplified geometry that has arcs and quadratic beziers
/// removed.
/// </summary>
HRESULT
Simplify
(
D2D1_GEOMETRY_SIMPLIFICATION_OPTION
simplificationOption
, { }
/// <summary>
/// Tessellates a geometry into triangles.
/// </summary>
HRESULT
Tessellate
(
FLOAT
flatteningTolerance
, {
return
Tessellate
(&
worldTransform
,
flatteningTolerance
,
tessellationSink
); }
/// <summary>
/// Tessellates a geometry into triangles.
/// </summary>
HRESULT
Tessellate
( { }
/// <summary>
/// Tessellates a geometry into triangles.
/// </summary>
HRESULT
Tessellate
( { }
/// <summary>
/// Performs a combine operation between the two geometries to produce a resulting
/// geometry.
/// </summary>
HRESULT
CombineWithGeometry
(
D2D1_COMBINE_MODE
combineMode
,
FLOAT
flatteningTolerance
, {
return
CombineWithGeometry
(
inputGeometry
,
combineMode
, &
inputGeometryTransform
,
flatteningTolerance
,
geometrySink
); }
/// <summary>
/// Performs a combine operation between the two geometries to produce a resulting
/// geometry.
/// </summary>
HRESULT
CombineWithGeometry
(
D2D1_COMBINE_MODE
combineMode
, { }
/// <summary>
/// Performs a combine operation between the two geometries to produce a resulting
/// geometry.
/// </summary>
HRESULT
CombineWithGeometry
(
D2D1_COMBINE_MODE
combineMode
, { }
/// <summary>
/// Computes the outline of the geometry. The result is written back into a
/// simplified geometry sink.
/// </summary>
HRESULT
Outline
(
FLOAT
flatteningTolerance
, {
return
Outline
(&
worldTransform
,
flatteningTolerance
,
geometrySink
); }
/// <summary>
/// Computes the outline of the geometry. The result is written back into a
/// simplified geometry sink.
/// </summary>
HRESULT
Outline
( { }
/// <summary>
/// Computes the outline of the geometry. The result is written back into a
/// simplified geometry sink.
/// </summary>
HRESULT
Outline
( { }
/// <summary>
/// Computes the area of the geometry.
/// </summary>
HRESULT
ComputeArea
(
FLOAT
flatteningTolerance
, {
return
ComputeArea
(&
worldTransform
,
flatteningTolerance
,
area
); }
/// <summary>
/// Computes the area of the geometry.
/// </summary>
HRESULT
ComputeArea
( { }
/// <summary>
/// Computes the area of the geometry.
/// </summary>
HRESULT
ComputeArea
( { }
/// <summary>
/// Computes the length of the geometry.
/// </summary>
HRESULT
ComputeLength
(
FLOAT
flatteningTolerance
, {
return
ComputeLength
(&
worldTransform
,
flatteningTolerance
,
length
); }
/// <summary>
/// Computes the length of the geometry.
/// </summary>
HRESULT
ComputeLength
( { }
/// <summary>
/// Computes the length of the geometry.
/// </summary>
HRESULT
ComputeLength
( { }
/// <summary>
/// Computes the point and tangent a given distance along the path.
/// </summary>
HRESULT
ComputePointAtLength
(
FLOAT
length
,
FLOAT
flatteningTolerance
, {
return
ComputePointAtLength
(
length
, &
worldTransform
,
flatteningTolerance
,
point
,
unitTangentVector
); }
/// <summary>
/// Computes the point and tangent a given distance along the path.
/// </summary>
HRESULT
ComputePointAtLength
(
FLOAT
length
, { }
/// <summary>
/// Computes the point and tangent a given distance along the path.
/// </summary>
HRESULT
ComputePointAtLength
(
FLOAT
length
, { }
/// <summary>
/// Get the geometry and widen it as well as apply an optional pen style.
/// </summary>
HRESULT
Widen
(
FLOAT
strokeWidth
,
FLOAT
flatteningTolerance
, {
return
Widen
(
strokeWidth
,
strokeStyle
, &
worldTransform
,
flatteningTolerance
,
geometrySink
); }
/// <summary>
/// Get the geometry and widen it as well as apply an optional pen style.
/// </summary>
HRESULT
Widen
(
FLOAT
strokeWidth
, { }
/// <summary>
/// Get the geometry and widen it as well as apply an optional pen style.
/// </summary>
HRESULT
Widen
(
FLOAT
strokeWidth
, { } };
// interface ID2D1Geometry
/// <summary>
/// Describes a two-dimensional rectangle.
/// </summary>
{ };
// interface ID2D1RectangleGeometry
/// <summary>
/// Describes a rounded rectangle.
/// </summary>
{ };
// interface ID2D1RoundedRectangleGeometry
/// <summary>
/// Represents an ellipse.
/// </summary>
{ };
// interface ID2D1EllipseGeometry
/// <summary>
/// Represents a composite geometry, composed of other ID2D1Geometry objects.
/// </summary>
{
UINT32
geometriesCount
};
// interface ID2D1GeometryGroup
/// <summary>
/// Represents a geometry that has been transformed.
/// </summary>
{ };
// interface ID2D1TransformedGeometry
/// <summary>
/// Describes a geometric path that does not contain quadratic bezier curves or
/// arcs.
/// </summary>
{
D2D1_FILL_MODE
fillMode
D2D1_PATH_SEGMENT
vertexFlags
D2D1_POINT_2F
startPoint
,
D2D1_FIGURE_BEGIN
figureBegin
UINT32
pointsCount
UINT32
beziersCount
D2D1_FIGURE_END
figureEnd
};
// interface ID2D1SimplifiedGeometrySink
/// <summary>
/// Describes a geometric path that can contain lines, arcs, cubic Bezier curves,
/// and quadratic Bezier curves.
/// </summary>
{
D2D1_POINT_2F
point
UINT32
beziersCount
void
AddBezier
( ) {
AddBezier
(&
bezier
); }
void
AddQuadraticBezier
( ) {
AddQuadraticBezier
(&
bezier
); }
void
AddArc
( ) {
AddArc
(&
arc
); } };
// interface ID2D1GeometrySink
/// <summary>
/// Populates an ID2D1Mesh object with triangles.
/// </summary>
{
UINT32
trianglesCount
};
// interface ID2D1TessellationSink
/// <summary>
/// Represents a complex shape that may be composed of arcs, curves, and lines.
/// </summary>
{
/// <summary>
/// Opens a geometry sink that will be used to create this path geometry.
/// </summary>
/// <summary>
/// Retrieve the contents of this geometry. The caller passes an implementation of a
/// ID2D1GeometrySink interface to receive the data.
/// </summary>
};
// interface ID2D1PathGeometry
/// <summary>
/// Represents a set of vertices that form a list of triangles.
/// </summary>
{
/// <summary>
/// Opens the mesh for population.
/// </summary>
};
// interface ID2D1Mesh
/// <summary>
/// Represents the backing store required to render a layer.
/// </summary>
{ };
// interface ID2D1Layer
/// <summary>
/// Represents the drawing state of a render target: the antialiasing mode,
/// transform, tags, and text-rendering options.
/// </summary>
{
/// <summary>
/// Retrieves the state currently contained within this state block resource.
/// </summary>
/// <summary>
/// Sets the state description of this state block resource.
/// </summary>
/// <summary>
/// Sets the text rendering parameters of this state block resource.
/// </summary>
/// <summary>
/// Retrieves the text rendering parameters contained within this state block
/// resource. If a NULL text rendering parameter was specified, NULL will be
/// returned.
/// </summary>
void
SetDescription
( ) {
SetDescription
(&
stateDescription
); } };
// interface ID2D1DrawingStateBlock
/// <summary>
/// Represents an object that can receive drawing commands. Interfaces that inherit
/// from ID2D1RenderTarget render the drawing commands they receive in different
/// ways.
/// </summary>
{
/// <summary>
/// Create a D2D bitmap by copying from memory, or create uninitialized.
/// </summary>
D2D1_SIZE_U
size
,
UINT32
pitch
,
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
/// <summary>
/// Create a D2D bitmap by sharing bits from another resource. The bitmap must be
/// compatible with the render target for the call to succeed. For example, an
/// IWICBitmap can be shared with a software target, or a DXGI surface can be shared
/// with a DXGI render target.
/// </summary>
/// <summary>
/// Creates a bitmap brush. The bitmap is scaled, rotated, skewed or tiled to fill
/// or pen a geometry.
/// </summary>
/// <summary>
/// A gradient stop collection represents a set of stops in an ideal unit length.
/// This is the source resource for a linear gradient and radial gradient brush.
/// </summary>
/// <param name="colorInterpolationGamma">Specifies which space the color
/// interpolation occurs in.</param>
/// <param name="extendMode">Specifies how the gradient will be extended outside of
/// the unit length.</param>
D2D1_GAMMA
colorInterpolationGamma
,
D2D1_EXTEND_MODE
extendMode
,
/// <summary>
/// Creates a bitmap render target whose bitmap can be used as a source for
/// rendering in the API.
/// </summary>
/// <param name="desiredSize">The requested size of the target in DIPs. If the pixel
/// size is not specified, the DPI is inherited from the parent target. However, the
/// render target will never contain a fractional number of pixels.</param>
/// <param name="desiredPixelSize">The requested size of the render target in
/// pixels. If the DIP size is also specified, the DPI is calculated from these two
/// values. If the desired size is not specified, the DPI is inherited from the
/// parent render target. If neither value is specified, the compatible render
/// target will be the same size and have the same DPI as the parent target.</param>
/// <param name="desiredFormat">The desired pixel format. The format must be
/// compatible with the parent render target type. If the format is not specified,
/// it will be inherited from the parent render target.</param>
/// <param name="options">Allows the caller to retrieve a GDI compatible render
/// target.</param>
/// <param name="bitmapRenderTarget">The returned bitmap render target.</param>
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS
options
,
/// <summary>
/// Creates a layer resource that can be used on any target and which will resize
/// under the covers if necessary.
/// </summary>
/// <param name="size">The resolution independent minimum size hint for the layer
/// resource. Specify this to prevent unwanted reallocation of the layer backing
/// store. The size is in DIPs, but, it is unaffected by the current world
/// transform. If the size is unspecified, the returned resource is a placeholder
/// and the backing store will be allocated to be the minimum size that can hold the
/// content when the layer is pushed.</param>
/// <summary>
/// Create a D2D mesh.
/// </summary>
D2D1_POINT_2F
point0
,
D2D1_POINT_2F
point1
,
FLOAT
strokeWidth
=
1.0f
,
FLOAT
strokeWidth
=
1.0f
,
FLOAT
strokeWidth
=
1.0f
,
FLOAT
strokeWidth
=
1.0f
,
FLOAT
strokeWidth
=
1.0f
,
/// <param name="opacityBrush">An optionally specified opacity brush. Only the alpha
/// channel of the corresponding brush will be sampled and will be applied to the
/// entire fill of the geometry. If this brush is specified, the fill brush must be
/// a bitmap brush with an extend mode of D2D1_EXTEND_MODE_CLAMP.</param>
/// <summary>
/// Fill a mesh. Since meshes can only render aliased content, the render target
/// antialiasing mode must be set to aliased.
/// </summary>
/// <summary>
/// Fill using the alpha channel of the supplied opacity mask bitmap. The brush
/// opacity will be modulated by the mask. The render target antialiasing mode must
/// be set to aliased.
/// </summary>
D2D1_OPACITY_MASK_CONTENT
content
,
FLOAT
opacity
=
1.0f
,
D2D1_BITMAP_INTERPOLATION_MODE
interpolationMode
=
D2D1_BITMAP_INTERPOLATION_MODE_LINEAR
,
/// <summary>
/// Draws the text within the given layout rectangle and by default also performs
/// baseline snapping.
/// </summary>
UINT32
stringLength
,
D2D1_DRAW_TEXT_OPTIONS
options
=
D2D1_DRAW_TEXT_OPTIONS_NONE
,
DWRITE_MEASURING_MODE
measuringMode
=
DWRITE_MEASURING_MODE_NATURAL
/// <summary>
/// Draw a text layout object. If the layout is not subsequently changed, this can
/// be more efficient than DrawText when drawing the same layout repeatedly.
/// </summary>
/// <param name="options">The specified text options. If D2D1_DRAW_TEXT_OPTIONS_CLIP
/// is used, the text is clipped to the layout bounds. These bounds are derived from
/// the origin and the layout bounds of the corresponding IDWriteTextLayout object.
/// </param>
D2D1_POINT_2F
origin
,
D2D1_DRAW_TEXT_OPTIONS
options
=
D2D1_DRAW_TEXT_OPTIONS_NONE
D2D1_POINT_2F
baselineOrigin
,
DWRITE_MEASURING_MODE
measuringMode
=
DWRITE_MEASURING_MODE_NATURAL
D2D1_ANTIALIAS_MODE
antialiasMode
D2D1_TEXT_ANTIALIAS_MODE
textAntialiasMode
/// <summary>
/// Retrieve the text render parameters. NOTE: If NULL is specified to
/// SetTextRenderingParameters, NULL will be returned.
/// </summary>
/// <summary>
/// Set a tag to correspond to the succeeding primitives. If an error occurs
/// rendering a primitive, the tags can be returned from the Flush or EndDraw call.
/// </summary>
D2D1_TAG
tag1
,
D2D1_TAG
tag2
/// <summary>
/// Retrieves the currently set tags. This does not retrieve the tags corresponding
/// to any primitive that is in error.
/// </summary>
/// <summary>
/// Start a layer of drawing calls. The way in which the layer must be resolved is
/// specified first as well as the logical resource that stores the layer
/// parameters. The supplied layer resource might grow if the specified content
/// cannot fit inside it. The layer will grow monotonically on each axis. If a NULL
/// ID2D1Layer is provided, then a layer resource will be allocated automatically.
/// </summary>
/// <summary>
/// Ends a layer that was defined with particular layer resources.
/// </summary>
/// <summary>
/// Gets the current drawing state and saves it into the supplied
/// IDrawingStatckBlock.
/// </summary>
/// <summary>
/// Copies the state stored in the block interface.
/// </summary>
/// <summary>
/// Pushes a clip. The clip can be antialiased. The clip must be axis aligned. If
/// the current world transform is not axis preserving, then the bounding box of the
/// transformed clip rect will be used. The clip will remain in effect until a
/// PopAxisAligned clip call is made.
/// </summary>
D2D1_ANTIALIAS_MODE
antialiasMode
/// <summary>
/// Start drawing on this render target. Draw calls can only be issued between a
/// BeginDraw and EndDraw call.
/// </summary>
/// <summary>
/// Ends drawing on the render target, error results can be retrieved at this time,
/// or when calling flush.
/// </summary>
/// <summary>
/// Sets the DPI on the render target. This results in the render target being
/// interpreted to a different scale. Neither DPI can be negative. If zero is
/// specified for both, the system DPI is chosen. If one is zero and the other
/// unspecified, the DPI is not changed.
/// </summary>
FLOAT
dpiX
,
FLOAT
dpiY
/// <summary>
/// Return the current DPI from the target.
/// </summary>
/// <summary>
/// Returns the size of the render target in DIPs.
/// </summary>
/// <summary>
/// Returns the size of the render target in pixels.
/// </summary>
/// <summary>
/// Returns the maximum bitmap and render target size that is guaranteed to be
/// supported by the render target.
/// </summary>
/// <summary>
/// Returns true if the given properties are supported by this render target. The
/// DPI is ignored. NOTE: If the render target type is software, then neither
/// D2D1_FEATURE_LEVEL_9 nor D2D1_FEATURE_LEVEL_10 will be considered to be
/// supported.
/// </summary>
HRESULT
CreateBitmap
(
D2D1_SIZE_U
size
,
UINT32
pitch
, ) {
return
CreateBitmap
(
size
,
srcData
,
pitch
, &
bitmapProperties
,
bitmap
); }
HRESULT
CreateBitmap
(
D2D1_SIZE_U
size
, ) { }
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
HRESULT
CreateBitmapFromWicBitmap
( ) {
return
CreateBitmapFromWicBitmap
(
wicBitmapSource
, &
bitmapProperties
,
bitmap
); }
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
HRESULT
CreateBitmapFromWicBitmap
( ) { }
/// <summary>
/// Creates a bitmap brush. The bitmap is scaled, rotated, skewed or tiled to fill
/// or pen a geometry.
/// </summary>
HRESULT
CreateBitmapBrush
( ) { }
/// <summary>
/// Creates a bitmap brush. The bitmap is scaled, rotated, skewed or tiled to fill
/// or pen a geometry.
/// </summary>
HRESULT
CreateBitmapBrush
( ) { }
/// <summary>
/// Creates a bitmap brush. The bitmap is scaled, rotated, skewed or tiled to fill
/// or pen a geometry.
/// </summary>
HRESULT
CreateBitmapBrush
( ) {
return
CreateBitmapBrush
(
bitmap
, &
bitmapBrushProperties
, &
brushProperties
,
bitmapBrush
); }
HRESULT
CreateSolidColorBrush
( ) { }
HRESULT
CreateSolidColorBrush
( ) {
return
CreateSolidColorBrush
(&
color
, &
brushProperties
,
solidColorBrush
); }
HRESULT
CreateGradientStopCollection
(
UINT32
gradientStopsCount
, ) {
return
CreateGradientStopCollection
(
gradientStops
,
gradientStopsCount
,
D2D1_GAMMA_2_2
,
D2D1_EXTEND_MODE_CLAMP
,
gradientStopCollection
); }
HRESULT
CreateLinearGradientBrush
( ) { }
HRESULT
CreateLinearGradientBrush
( ) {
return
CreateLinearGradientBrush
(&
linearGradientBrushProperties
, &
brushProperties
,
gradientStopCollection
,
linearGradientBrush
); }
HRESULT
CreateRadialGradientBrush
( ) { }
HRESULT
CreateRadialGradientBrush
( ) {
return
CreateRadialGradientBrush
(&
radialGradientBrushProperties
, &
brushProperties
,
gradientStopCollection
,
radialGradientBrush
); }
HRESULT
CreateCompatibleRenderTarget
( ) { }
HRESULT
CreateCompatibleRenderTarget
(
D2D1_SIZE_F
desiredSize
, ) { }
HRESULT
CreateCompatibleRenderTarget
(
D2D1_SIZE_F
desiredSize
,
D2D1_SIZE_U
desiredPixelSize
, ) { }
HRESULT
CreateCompatibleRenderTarget
(
D2D1_SIZE_F
desiredSize
,
D2D1_SIZE_U
desiredPixelSize
,
D2D1_PIXEL_FORMAT
desiredFormat
, ) {
return
CreateCompatibleRenderTarget
(&
desiredSize
, &
desiredPixelSize
, &
desiredFormat
,
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE
,
bitmapRenderTarget
); }
HRESULT
CreateCompatibleRenderTarget
(
D2D1_SIZE_F
desiredSize
,
D2D1_SIZE_U
desiredPixelSize
,
D2D1_PIXEL_FORMAT
desiredFormat
,
D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS
options
, ) {
return
CreateCompatibleRenderTarget
(&
desiredSize
, &
desiredPixelSize
, &
desiredFormat
,
options
,
bitmapRenderTarget
); }
HRESULT
CreateLayer
(
D2D1_SIZE_F
size
, ) {
return
CreateLayer
(&
size
,
layer
); }
HRESULT
CreateLayer
( ) { }
void
DrawRectangle
(
FLOAT
strokeWidth
=
1.0f
, ) {
DrawRectangle
(&
rect
,
brush
,
strokeWidth
,
strokeStyle
); }
void
FillRectangle
( ) {
FillRectangle
(&
rect
,
brush
); }
void
DrawRoundedRectangle
(
FLOAT
strokeWidth
=
1.0f
, ) {
DrawRoundedRectangle
(&
roundedRect
,
brush
,
strokeWidth
,
strokeStyle
); }
void
FillRoundedRectangle
( ) {
FillRoundedRectangle
(&
roundedRect
,
brush
); }
void
DrawEllipse
(
FLOAT
strokeWidth
=
1.0f
, ) {
DrawEllipse
(&
ellipse
,
brush
,
strokeWidth
,
strokeStyle
); }
void
FillEllipse
( ) {
FillEllipse
(&
ellipse
,
brush
); }
void
FillOpacityMask
(
D2D1_OPACITY_MASK_CONTENT
content
, ) {
FillOpacityMask
(
opacityMask
,
brush
,
content
, &
destinationRectangle
, &
sourceRectangle
); }
void
DrawBitmap
(
FLOAT
opacity
=
1.0f
,
D2D1_BITMAP_INTERPOLATION_MODE
interpolationMode
=
D2D1_BITMAP_INTERPOLATION_MODE_LINEAR
, ) {
DrawBitmap
(
bitmap
, &
destinationRectangle
,
opacity
,
interpolationMode
,
sourceRectangle
); }
void
DrawBitmap
(
FLOAT
opacity
,
D2D1_BITMAP_INTERPOLATION_MODE
interpolationMode
, ) {
DrawBitmap
(
bitmap
, &
destinationRectangle
,
opacity
,
interpolationMode
, &
sourceRectangle
); }
void
SetTransform
( ) {
SetTransform
(&
transform
); }
void
PushLayer
( ) {
PushLayer
(&
layerParameters
,
layer
); }
void
PushAxisAlignedClip
(
D2D1_ANTIALIAS_MODE
antialiasMode
) {
return
PushAxisAlignedClip
(&
clipRect
,
antialiasMode
); }
void
Clear
( ) {
return
Clear
(&
clearColor
); }
/// <summary>
/// Draws the text within the given layout rectangle and by default also performs
/// baseline snapping.
/// </summary>
void
UINT32
stringLength
,
D2D1_DRAW_TEXT_OPTIONS
options
=
D2D1_DRAW_TEXT_OPTIONS_NONE
,
DWRITE_MEASURING_MODE
measuringMode
=
DWRITE_MEASURING_MODE_NATURAL
) { }
BOOL
IsSupported
( {
return
IsSupported
(&
renderTargetProperties
); } };
// interface ID2D1RenderTarget
/// <summary>
/// Renders to an intermediate texture created by the CreateCompatibleRenderTarget
/// method.
/// </summary>
{ };
// interface ID2D1BitmapRenderTarget
/// <summary>
/// Renders drawing instructions to a window.
/// </summary>
{
/// <summary>
/// Resize the buffer underlying the render target. This operation might fail if
/// there is insufficient video memory or system memory, or if the render target is
/// resized beyond the maximum bitmap size. If the method fails, the render target
/// will be placed in a zombie state and D2DERR_RECREATE_TARGET will be returned
/// from it when EndDraw is called. In addition an appropriate failure result will
/// be returned from Resize.
/// </summary>
HRESULT
Resize
( ) {
return
Resize
(&
pixelSize
); } };
// interface ID2D1HwndRenderTarget
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion #pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
/// <summary>
/// Provides access to an device context that can accept GDI drawing commands.
/// </summary>
{
D2D1_DC_INITIALIZE_MODE
mode
, };
// interface ID2D1GdiInteropRenderTarget
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion #pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
/// <summary>
/// Issues drawing commands to a GDI device context.
/// </summary>
{ };
// interface ID2D1DCRenderTarget
/// <summary>
/// The root factory interface for all of D2D's objects.
/// </summary>
{
/// <summary>
/// Cause the factory to refresh any system metrics that it might have been snapped
/// on factory creation.
/// </summary>
/// <summary>
/// Retrieves the current desktop DPI. To refresh this, call ReloadSystemMetrics.
/// Note: this method is deprecated. Use DisplayProperties::LogicalDpi for Windows
/// Store Apps and GetDpiForWindow for Win32 Apps.
/// </summary>
/// <summary>
/// Create a geometry which holds other geometries.
/// </summary>
D2D1_FILL_MODE
fillMode
,
UINT32
geometriesCount
,
/// <summary>
/// Returns an initially empty path geometry interface. A geometry sink is created
/// off the interface to populate it.
/// </summary>
/// <summary>
/// Allows a non-default stroke style to be specified for a given geometry at draw
/// time.
/// </summary>
UINT32
dashesCount
,
/// <summary>
/// Creates a new drawing state block, this can be used in subsequent
/// SaveDrawingState and RestoreDrawingState operations on the render target.
/// </summary>
/// <summary>
/// Creates a render target which is a source of bitmaps.
/// </summary>
/// <summary>
/// Creates a render target that appears on the display.
/// </summary>
/// <summary>
/// Creates a render target that draws to a DXGI Surface. The device that owns the
/// surface is used for rendering.
/// </summary>
/// <summary>
/// Creates a render target that draws to a GDI device context.
/// </summary>
HRESULT
CreateRectangleGeometry
( ) {
return
CreateRectangleGeometry
(&
rectangle
,
rectangleGeometry
); }
HRESULT
CreateRoundedRectangleGeometry
( ) {
return
CreateRoundedRectangleGeometry
(&
roundedRectangle
,
roundedRectangleGeometry
); }
HRESULT
CreateEllipseGeometry
( ) {
return
CreateEllipseGeometry
(&
ellipse
,
ellipseGeometry
); }
HRESULT
CreateTransformedGeometry
( ) {
return
CreateTransformedGeometry
(
sourceGeometry
, &
transform
,
transformedGeometry
); }
HRESULT
CreateStrokeStyle
(
UINT32
dashesCount
, ) {
return
CreateStrokeStyle
(&
strokeStyleProperties
,
dashes
,
dashesCount
,
strokeStyle
); }
HRESULT
CreateDrawingStateBlock
( ) { }
HRESULT
CreateDrawingStateBlock
( ) { }
HRESULT
CreateWicBitmapRenderTarget
( ) {
return
CreateWicBitmapRenderTarget
(
target
, &
renderTargetProperties
,
renderTarget
); }
HRESULT
CreateHwndRenderTarget
( ) {
return
CreateHwndRenderTarget
(&
renderTargetProperties
, &
hwndRenderTargetProperties
,
hwndRenderTarget
); }
HRESULT
CreateDxgiSurfaceRenderTarget
( ) {
return
CreateDxgiSurfaceRenderTarget
(
dxgiSurface
, &
renderTargetProperties
,
renderTarget
); } };
// interface ID2D1Factory
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion
#endif
#ifdef D2D_USE_C_DEFINITIONS
#pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef interface ID2D1Resource ID2D1Resource;
typedef interface ID2D1Image ID2D1Image;
typedef interface ID2D1Bitmap ID2D1Bitmap;
typedef interface ID2D1GradientStopCollection ID2D1GradientStopCollection;
typedef interface ID2D1Brush ID2D1Brush;
typedef interface ID2D1BitmapBrush ID2D1BitmapBrush;
typedef interface ID2D1SolidColorBrush ID2D1SolidColorBrush;
typedef interface ID2D1LinearGradientBrush ID2D1LinearGradientBrush;
typedef interface ID2D1RadialGradientBrush ID2D1RadialGradientBrush;
typedef interface ID2D1StrokeStyle ID2D1StrokeStyle;
typedef interface ID2D1Geometry ID2D1Geometry;
typedef interface ID2D1RectangleGeometry ID2D1RectangleGeometry;
typedef interface ID2D1RoundedRectangleGeometry ID2D1RoundedRectangleGeometry;
typedef interface ID2D1EllipseGeometry ID2D1EllipseGeometry;
typedef interface ID2D1GeometryGroup ID2D1GeometryGroup;
typedef interface ID2D1TransformedGeometry ID2D1TransformedGeometry;
typedef interface ID2D1SimplifiedGeometrySink ID2D1SimplifiedGeometrySink;
typedef interface ID2D1GeometrySink ID2D1GeometrySink;
typedef interface ID2D1TessellationSink ID2D1TessellationSink;
typedef interface ID2D1PathGeometry ID2D1PathGeometry;
typedef interface ID2D1Mesh ID2D1Mesh;
typedef interface ID2D1Layer ID2D1Layer;
typedef interface ID2D1DrawingStateBlock ID2D1DrawingStateBlock;
typedef interface ID2D1RenderTarget ID2D1RenderTarget;
typedef interface ID2D1BitmapRenderTarget ID2D1BitmapRenderTarget;
typedef interface ID2D1HwndRenderTarget ID2D1HwndRenderTarget;
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion
#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef interface ID2D1GdiInteropRenderTarget ID2D1GdiInteropRenderTarget;
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion
#pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef interface ID2D1DCRenderTarget ID2D1DCRenderTarget;
typedef interface ID2D1Factory ID2D1Factory;
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion
#endif
#pragma region Application Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#ifdef __cplusplus
extern
"C"
{
#endif
//
// This export cannot be in a namespace because compiler name mangling isn't consistent
// also, this must be 'C' callable.
//
D2D1CreateFactory
( );
D2D1MakeRotateMatrix
( );
D2D1MakeSkewMatrix
( );
D2D1IsMatrixInvertible
( );
D2D1InvertMatrix
( );
#ifdef __cplusplus
}
#endif
#ifndef D2D1FORCEINLINE
#define D2D1FORCEINLINE FORCEINLINE #endif // #ifndef D2D1FORCEINLINE
#include <d2d1helper.h>
#ifndef D2D_USE_C_DEFINITIONS
inline
HRESULT
D2D1CreateFactory
( ) {
return
D2D1CreateFactory
(
factoryType
,
riid
,
factory
); }
template
<
class
Factory
>
HRESULT
D2D1CreateFactory
( ) {
return
D2D1CreateFactory
(
factoryType
, __uuidof(
Factory
),
reinterpret_cast
<
void
**>(
factory
)); }
template
<
class
Factory
>
HRESULT
D2D1CreateFactory
( ) {
return
D2D1CreateFactory
(
factoryType
, __uuidof(
Factory
), &
factoryOptions
,
reinterpret_cast
<
void
**>(
ppFactory
)); }
#endif // #ifndef D2D_USE_C_DEFINITIONS
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
#pragma endregion
#endif // #ifndef _D2D1_H_