libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-11-24 08:30:16 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity
1167a06a5a
RetroArch/gfx/include/dxsdk/d2d1_1.h
orbea 28ff4b391a Clean up white space.
2019-02-03 16:00:50 -08:00

2476 lines
73 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// This file is automatically generated. Please do not edit it directly.
//
// File name: D2D1_1.h
//---------------------------------------------------------------------------
#ifdef _MSC_VER
#pragma once
#endif // #ifdef _MSC_VER
#ifndef _D2D1_1_H_
#define _D2D1_1_H_
#ifndef _D2D1_H_
#include <d2d1.h>
#endif // #ifndef _D2D1_H_
#ifndef _D2D1_EFFECTS_
#include <d2d1effects.h>
#endif // #ifndef _D2D1_EFFECTS_
/*#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)*/
#include <dxgi.h>
/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
/*#include <winapifamily.h>*/
/*#pragma region Application Family*/
/*#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)*/
typedef interface ID2D1ColorContext ID2D1ColorContext;
typedef interface IWICColorContext IWICColorContext;
typedef interface IWICImagingFactory IWICImagingFactory;
typedef interface IPrintDocumentPackageTarget IPrintDocumentPackageTarget;
typedef interface IDWriteFactory IDWriteFactory;
typedef struct DWRITE_GLYPH_RUN_DESCRIPTION DWRITE_GLYPH_RUN_DESCRIPTION;
typedef struct D2D1_PROPERTY_BINDING D2D1_PROPERTY_BINDING;
/// <summary>
/// Function pointer to construct a new effect once registered.
/// </summary>
typedef HRESULT (CALLBACK *PD2D1_EFFECT_FACTORY)(
_Outptr_ IUnknown **effectImpl
);
#ifndef D2D_USE_C_DEFINITIONS
interface ID2D1Device;
interface ID2D1Effect;
#else
typedef interface ID2D1Device ID2D1Device;
typedef interface ID2D1Effect ID2D1Effect;
#endif
#define D2D1_INVALID_PROPERTY_INDEX UINT_MAX
typedef D2D_RECT_L D2D1_RECT_L;
typedef D2D_POINT_2L D2D1_POINT_2L;
/// <summary>
/// This defines the valid property types that can be used in an effect property
/// interface.
/// </summary>
typedef enum D2D1_PROPERTY_TYPE
{
D2D1_PROPERTY_TYPE_UNKNOWN = 0,
D2D1_PROPERTY_TYPE_STRING = 1,
D2D1_PROPERTY_TYPE_BOOL = 2,
D2D1_PROPERTY_TYPE_UINT32 = 3,
D2D1_PROPERTY_TYPE_INT32 = 4,
D2D1_PROPERTY_TYPE_FLOAT = 5,
D2D1_PROPERTY_TYPE_VECTOR2 = 6,
D2D1_PROPERTY_TYPE_VECTOR3 = 7,
D2D1_PROPERTY_TYPE_VECTOR4 = 8,
D2D1_PROPERTY_TYPE_BLOB = 9,
D2D1_PROPERTY_TYPE_IUNKNOWN = 10,
D2D1_PROPERTY_TYPE_ENUM = 11,
D2D1_PROPERTY_TYPE_ARRAY = 12,
D2D1_PROPERTY_TYPE_CLSID = 13,
D2D1_PROPERTY_TYPE_MATRIX_3X2 = 14,
D2D1_PROPERTY_TYPE_MATRIX_4X3 = 15,
D2D1_PROPERTY_TYPE_MATRIX_4X4 = 16,
D2D1_PROPERTY_TYPE_MATRIX_5X4 = 17,
D2D1_PROPERTY_TYPE_COLOR_CONTEXT = 18,
D2D1_PROPERTY_TYPE_FORCE_DWORD = 0xffffffff
} D2D1_PROPERTY_TYPE;
/// <summary>
/// This defines the list of system properties present on the root effect property
/// interface.
/// </summary>
typedef enum D2D1_PROPERTY
{
D2D1_PROPERTY_CLSID = 0x80000000,
D2D1_PROPERTY_DISPLAYNAME = 0x80000001,
D2D1_PROPERTY_AUTHOR = 0x80000002,
D2D1_PROPERTY_CATEGORY = 0x80000003,
D2D1_PROPERTY_DESCRIPTION = 0x80000004,
D2D1_PROPERTY_INPUTS = 0x80000005,
D2D1_PROPERTY_CACHED = 0x80000006,
D2D1_PROPERTY_PRECISION = 0x80000007,
D2D1_PROPERTY_MIN_INPUTS = 0x80000008,
D2D1_PROPERTY_MAX_INPUTS = 0x80000009,
D2D1_PROPERTY_FORCE_DWORD = 0xffffffff
} D2D1_PROPERTY;
/// <summary>
/// This defines the indices of sub-properties that may be present on any parent
/// property.
/// </summary>
typedef enum D2D1_SUBPROPERTY
{
D2D1_SUBPROPERTY_DISPLAYNAME = 0x80000000,
D2D1_SUBPROPERTY_ISREADONLY = 0x80000001,
D2D1_SUBPROPERTY_MIN = 0x80000002,
D2D1_SUBPROPERTY_MAX = 0x80000003,
D2D1_SUBPROPERTY_DEFAULT = 0x80000004,
D2D1_SUBPROPERTY_FIELDS = 0x80000005,
D2D1_SUBPROPERTY_INDEX = 0x80000006,
D2D1_SUBPROPERTY_FORCE_DWORD = 0xffffffff
} D2D1_SUBPROPERTY;
/// <summary>
/// Specifies how the bitmap can be used.
/// </summary>
typedef enum D2D1_BITMAP_OPTIONS
{
/// <summary>
/// The bitmap is created with default properties.
/// </summary>
D2D1_BITMAP_OPTIONS_NONE = 0x00000000,
/// <summary>
/// The bitmap can be specified as a target in ID2D1DeviceContext::SetTarget
/// </summary>
D2D1_BITMAP_OPTIONS_TARGET = 0x00000001,
/// <summary>
/// The bitmap cannot be used as an input to DrawBitmap, DrawImage, in a bitmap
/// brush or as an input to an effect.
/// </summary>
D2D1_BITMAP_OPTIONS_CANNOT_DRAW = 0x00000002,
/// <summary>
/// The bitmap can be read from the CPU.
/// </summary>
D2D1_BITMAP_OPTIONS_CPU_READ = 0x00000004,
/// <summary>
/// The bitmap works with the ID2D1GdiInteropRenderTarget::GetDC API.
/// </summary>
D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE = 0x00000008,
D2D1_BITMAP_OPTIONS_FORCE_DWORD = 0xffffffff
} D2D1_BITMAP_OPTIONS;
DEFINE_ENUM_FLAG_OPERATORS(D2D1_BITMAP_OPTIONS);
/// <summary>
/// Specifies the composite mode that will be applied.
/// </summary>
typedef enum D2D1_COMPOSITE_MODE
{
D2D1_COMPOSITE_MODE_SOURCE_OVER = 0,
D2D1_COMPOSITE_MODE_DESTINATION_OVER = 1,
D2D1_COMPOSITE_MODE_SOURCE_IN = 2,
D2D1_COMPOSITE_MODE_DESTINATION_IN = 3,
D2D1_COMPOSITE_MODE_SOURCE_OUT = 4,
D2D1_COMPOSITE_MODE_DESTINATION_OUT = 5,
D2D1_COMPOSITE_MODE_SOURCE_ATOP = 6,
D2D1_COMPOSITE_MODE_DESTINATION_ATOP = 7,
D2D1_COMPOSITE_MODE_XOR = 8,
D2D1_COMPOSITE_MODE_PLUS = 9,
D2D1_COMPOSITE_MODE_SOURCE_COPY = 10,
D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY = 11,
D2D1_COMPOSITE_MODE_MASK_INVERT = 12,
D2D1_COMPOSITE_MODE_FORCE_DWORD = 0xffffffff
} D2D1_COMPOSITE_MODE;
/// <summary>
/// This specifies the precision that should be used in buffers allocated by D2D.
/// </summary>
typedef enum D2D1_BUFFER_PRECISION
{
D2D1_BUFFER_PRECISION_UNKNOWN = 0,
D2D1_BUFFER_PRECISION_8BPC_UNORM = 1,
D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = 2,
D2D1_BUFFER_PRECISION_16BPC_UNORM = 3,
D2D1_BUFFER_PRECISION_16BPC_FLOAT = 4,
D2D1_BUFFER_PRECISION_32BPC_FLOAT = 5,
D2D1_BUFFER_PRECISION_FORCE_DWORD = 0xffffffff
} D2D1_BUFFER_PRECISION;
/// <summary>
/// This describes how the individual mapping operation should be performed.
/// </summary>
typedef enum D2D1_MAP_OPTIONS
{
/// <summary>
/// The mapped pointer has undefined behavior.
/// </summary>
D2D1_MAP_OPTIONS_NONE = 0,
/// <summary>
/// The mapped pointer can be read from.
/// </summary>
D2D1_MAP_OPTIONS_READ = 1,
/// <summary>
/// The mapped pointer can be written to.
/// </summary>
D2D1_MAP_OPTIONS_WRITE = 2,
/// <summary>
/// The previous contents of the bitmap are discarded when it is mapped.
/// </summary>
D2D1_MAP_OPTIONS_DISCARD = 4,
D2D1_MAP_OPTIONS_FORCE_DWORD = 0xffffffff
} D2D1_MAP_OPTIONS;
DEFINE_ENUM_FLAG_OPERATORS(D2D1_MAP_OPTIONS);
/// <summary>
/// This is used to specify the quality of image scaling with
/// ID2D1DeviceContext::DrawImage and with the 2D Affine Transform Effect.
/// </summary>
typedef enum D2D1_INTERPOLATION_MODE
{
D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR,
D2D1_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR,
D2D1_INTERPOLATION_MODE_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC,
D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR,
D2D1_INTERPOLATION_MODE_ANISOTROPIC = D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC,
D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC,
D2D1_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff
} D2D1_INTERPOLATION_MODE;
/// <summary>
/// This specifies what units should be accepted by the D2D API.
/// </summary>
typedef enum D2D1_UNIT_MODE
{
D2D1_UNIT_MODE_DIPS = 0,
D2D1_UNIT_MODE_PIXELS = 1,
D2D1_UNIT_MODE_FORCE_DWORD = 0xffffffff
} D2D1_UNIT_MODE;
/// <summary>
/// Defines a color space.
/// </summary>
typedef enum D2D1_COLOR_SPACE
{
/// <summary>
/// The color space is described by accompanying data, such as a color profile.
/// </summary>
D2D1_COLOR_SPACE_CUSTOM = 0,
/// <summary>
/// The sRGB color space.
/// </summary>
D2D1_COLOR_SPACE_SRGB = 1,
/// <summary>
/// The scRGB color space.
/// </summary>
D2D1_COLOR_SPACE_SCRGB = 2,
D2D1_COLOR_SPACE_FORCE_DWORD = 0xffffffff
} D2D1_COLOR_SPACE;
/// <summary>
/// This specifies options that apply to the device context for its lifetime.
/// </summary>
typedef enum D2D1_DEVICE_CONTEXT_OPTIONS
{
D2D1_DEVICE_CONTEXT_OPTIONS_NONE = 0,
/// <summary>
/// Geometry rendering will be performed on many threads in parallel, a single
/// thread is the default.
/// </summary>
D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS = 1,
D2D1_DEVICE_CONTEXT_OPTIONS_FORCE_DWORD = 0xffffffff
} D2D1_DEVICE_CONTEXT_OPTIONS;
DEFINE_ENUM_FLAG_OPERATORS(D2D1_DEVICE_CONTEXT_OPTIONS);
/// <summary>
/// Defines how the world transform, dots per inch (dpi), and stroke width affect
/// the shape of the pen used to stroke a primitive.
/// </summary>
typedef enum D2D1_STROKE_TRANSFORM_TYPE
{
/// <summary>
/// The stroke respects the world transform, the DPI, and the stroke width.
/// </summary>
D2D1_STROKE_TRANSFORM_TYPE_NORMAL = 0,
/// <summary>
/// The stroke does not respect the world transform, but it does respect the DPI and
/// the stroke width.
/// </summary>
D2D1_STROKE_TRANSFORM_TYPE_FIXED = 1,
/// <summary>
/// The stroke is forced to one pixel wide.
/// </summary>
D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE = 2,
D2D1_STROKE_TRANSFORM_TYPE_FORCE_DWORD = 0xffffffff
} D2D1_STROKE_TRANSFORM_TYPE;
/// <summary>
/// A blend mode that applies to all primitives drawn on the context.
/// </summary>
typedef enum D2D1_PRIMITIVE_BLEND
{
D2D1_PRIMITIVE_BLEND_SOURCE_OVER = 0,
D2D1_PRIMITIVE_BLEND_COPY = 1,
D2D1_PRIMITIVE_BLEND_MIN = 2,
D2D1_PRIMITIVE_BLEND_ADD = 3,
D2D1_PRIMITIVE_BLEND_MAX = 4,
D2D1_PRIMITIVE_BLEND_FORCE_DWORD = 0xffffffff
} D2D1_PRIMITIVE_BLEND;
/// <summary>
/// This specifies the threading mode used while simultaneously creating the device,
/// factory, and device context.
/// </summary>
typedef enum D2D1_THREADING_MODE
{
/// <summary>
/// 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_THREADING_MODE_SINGLE_THREADED = D2D1_FACTORY_TYPE_SINGLE_THREADED,
/// <summary>
/// Resources may be invoked from multiple threads. Resources use interlocked
/// reference counting and their state is protected.
/// </summary>
D2D1_THREADING_MODE_MULTI_THREADED = D2D1_FACTORY_TYPE_MULTI_THREADED,
D2D1_THREADING_MODE_FORCE_DWORD = 0xffffffff
} D2D1_THREADING_MODE;
/// <summary>
/// This specifies how colors are interpolated.
/// </summary>
typedef enum D2D1_COLOR_INTERPOLATION_MODE
{
/// <summary>
/// Colors will be interpolated in straight alpha space.
/// </summary>
D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = 0,
/// <summary>
/// Colors will be interpolated in premultiplied alpha space.
/// </summary>
D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = 1,
D2D1_COLOR_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff
} D2D1_COLOR_INTERPOLATION_MODE;
typedef D2D_VECTOR_2F D2D1_VECTOR_2F;
typedef D2D_VECTOR_3F D2D1_VECTOR_3F;
typedef D2D_VECTOR_4F D2D1_VECTOR_4F;
/// <summary>
/// Extended bitmap properties.
/// </summary>
typedef struct D2D1_BITMAP_PROPERTIES1
{
D2D1_PIXEL_FORMAT pixelFormat;
FLOAT dpiX;
FLOAT dpiY;
/// <summary>
/// Specifies how the bitmap can be used.
/// </summary>
D2D1_BITMAP_OPTIONS bitmapOptions;
_Field_size_opt_(1) ID2D1ColorContext *colorContext;
} D2D1_BITMAP_PROPERTIES1;
/// <summary>
/// Describes mapped memory from the ID2D1Bitmap1::Map API.
/// </summary>
typedef struct D2D1_MAPPED_RECT
{
UINT32 pitch;
BYTE *bits;
} D2D1_MAPPED_RECT;
/// <summary>
/// This controls advanced settings of the Direct2D imaging pipeline.
/// </summary>
typedef struct D2D1_RENDERING_CONTROLS
{
/// <summary>
/// The default buffer precision, used if the precision isn't otherwise specified.
/// </summary>
D2D1_BUFFER_PRECISION bufferPrecision;
/// <summary>
/// The size of allocated tiles used to render imaging effects.
/// </summary>
D2D1_SIZE_U tileSize;
} D2D1_RENDERING_CONTROLS;
/// <summary>
/// This identifies a certain input connection of a certain effect.
/// </summary>
typedef struct D2D1_EFFECT_INPUT_DESCRIPTION
{
/// <summary>
/// The effect whose input connection is being specified.
/// </summary>
ID2D1Effect *effect;
/// <summary>
/// The index of the input connection into the specified effect.
/// </summary>
UINT32 inputIndex;
/// <summary>
/// The rectangle which would be available on the specified input connection during
/// render operations.
/// </summary>
D2D1_RECT_F inputRectangle;
} D2D1_EFFECT_INPUT_DESCRIPTION;
typedef D2D_MATRIX_4X3_F D2D1_MATRIX_4X3_F;
typedef D2D_MATRIX_4X4_F D2D1_MATRIX_4X4_F;
typedef D2D_MATRIX_5X4_F D2D1_MATRIX_5X4_F;
/// <summary>
/// Describes a point along a path.
/// </summary>
typedef struct D2D1_POINT_DESCRIPTION
{
D2D1_POINT_2F point;
D2D1_POINT_2F unitTangentVector;
UINT32 endSegment;
UINT32 endFigure;
FLOAT lengthToEndSegment;
} D2D1_POINT_DESCRIPTION;
/// <summary>
/// Creation properties for an image brush.
/// </summary>
typedef struct D2D1_IMAGE_BRUSH_PROPERTIES
{
D2D1_RECT_F sourceRectangle;
D2D1_EXTEND_MODE extendModeX;
D2D1_EXTEND_MODE extendModeY;
D2D1_INTERPOLATION_MODE interpolationMode;
} D2D1_IMAGE_BRUSH_PROPERTIES;
/// <summary>
/// Describes the extend modes and the interpolation mode of an ID2D1BitmapBrush.
/// </summary>
typedef struct D2D1_BITMAP_BRUSH_PROPERTIES1
{
D2D1_EXTEND_MODE extendModeX;
D2D1_EXTEND_MODE extendModeY;
D2D1_INTERPOLATION_MODE interpolationMode;
} D2D1_BITMAP_BRUSH_PROPERTIES1;
/// <summary>
/// This defines how geometries should be drawn and widened.
/// </summary>
typedef struct D2D1_STROKE_STYLE_PROPERTIES1
{
D2D1_CAP_STYLE startCap;
D2D1_CAP_STYLE endCap;
D2D1_CAP_STYLE dashCap;
D2D1_LINE_JOIN lineJoin;
FLOAT miterLimit;
D2D1_DASH_STYLE dashStyle;
FLOAT dashOffset;
/// <summary>
/// How the nib of the stroke is influenced by the context properties.
/// </summary>
D2D1_STROKE_TRANSFORM_TYPE transformType;
} D2D1_STROKE_STYLE_PROPERTIES1;
/// <summary>
/// Specifies how the layer contents should be prepared.
/// </summary>
typedef enum D2D1_LAYER_OPTIONS1
{
D2D1_LAYER_OPTIONS1_NONE = 0,
D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = 1,
D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = 2,
D2D1_LAYER_OPTIONS1_FORCE_DWORD = 0xffffffff
} D2D1_LAYER_OPTIONS1;
DEFINE_ENUM_FLAG_OPERATORS(D2D1_LAYER_OPTIONS1);
/// <summary>
/// All parameters related to pushing a layer.
/// </summary>
typedef struct D2D1_LAYER_PARAMETERS1
{
D2D1_RECT_F contentBounds;
_Field_size_opt_(1) ID2D1Geometry *geometricMask;
D2D1_ANTIALIAS_MODE maskAntialiasMode;
D2D1_MATRIX_3X2_F maskTransform;
FLOAT opacity;
_Field_size_opt_(1) ID2D1Brush *opacityBrush;
D2D1_LAYER_OPTIONS1 layerOptions;
} D2D1_LAYER_PARAMETERS1;
/// <summary>
/// Defines when font resources should be subset during printing.
/// </summary>
typedef enum D2D1_PRINT_FONT_SUBSET_MODE
{
/// <summary>
/// Subset for used glyphs, send and discard font resource after every five pages
/// </summary>
D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT = 0,
/// <summary>
/// Subset for used glyphs, send and discard font resource after each page
/// </summary>
D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE = 1,
/// <summary>
/// Do not subset, reuse font for all pages, send it after first page
/// </summary>
D2D1_PRINT_FONT_SUBSET_MODE_NONE = 2,
D2D1_PRINT_FONT_SUBSET_MODE_FORCE_DWORD = 0xffffffff
} D2D1_PRINT_FONT_SUBSET_MODE;
/// <summary>
/// This describes the drawing state.
/// </summary>
typedef struct D2D1_DRAWING_STATE_DESCRIPTION1
{
D2D1_ANTIALIAS_MODE antialiasMode;
D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode;
D2D1_TAG tag1;
D2D1_TAG tag2;
D2D1_MATRIX_3X2_F transform;
D2D1_PRIMITIVE_BLEND primitiveBlend;
D2D1_UNIT_MODE unitMode;
} D2D1_DRAWING_STATE_DESCRIPTION1;
/// <summary>
/// The creation properties for a ID2D1PrintControl object.
/// </summary>
typedef struct D2D1_PRINT_CONTROL_PROPERTIES
{
D2D1_PRINT_FONT_SUBSET_MODE fontSubset;
/// <summary>
/// DPI for rasterization of all unsupported D2D commands or options, defaults to
/// 150.0
/// </summary>
FLOAT rasterDPI;
/// <summary>
/// Color space for vector graphics in XPS package
/// </summary>
D2D1_COLOR_SPACE colorSpace;
} D2D1_PRINT_CONTROL_PROPERTIES;
/// <summary>
/// This specifies the options while simultaneously creating the device, factory,
/// and device context.
/// </summary>
typedef struct D2D1_CREATION_PROPERTIES
{
/// <summary>
/// Describes locking behavior of D2D resources
/// </summary>
D2D1_THREADING_MODE threadingMode;
D2D1_DEBUG_LEVEL debugLevel;
D2D1_DEVICE_CONTEXT_OPTIONS options;
} D2D1_CREATION_PROPERTIES;
EXTERN_C CONST IID IID_ID2D1GdiMetafileSink;
EXTERN_C CONST IID IID_ID2D1GdiMetafile;
EXTERN_C CONST IID IID_ID2D1CommandSink;
EXTERN_C CONST IID IID_ID2D1CommandList;
EXTERN_C CONST IID IID_ID2D1PrintControl;
EXTERN_C CONST IID IID_ID2D1ImageBrush;
EXTERN_C CONST IID IID_ID2D1BitmapBrush1;
EXTERN_C CONST IID IID_ID2D1StrokeStyle1;
EXTERN_C CONST IID IID_ID2D1PathGeometry1;
EXTERN_C CONST IID IID_ID2D1Properties;
EXTERN_C CONST IID IID_ID2D1Effect;
EXTERN_C CONST IID IID_ID2D1Bitmap1;
EXTERN_C CONST IID IID_ID2D1ColorContext;
EXTERN_C CONST IID IID_ID2D1GradientStopCollection1;
EXTERN_C CONST IID IID_ID2D1DrawingStateBlock1;
EXTERN_C CONST IID IID_ID2D1DeviceContext;
EXTERN_C CONST IID IID_ID2D1Device;
EXTERN_C CONST IID IID_ID2D1Factory1;
EXTERN_C CONST IID IID_ID2D1Multithread;
#ifndef D2D_USE_C_DEFINITIONS
/// <summary>
/// User-implementable interface for introspecting on a metafile.
/// </summary>
interface DX_DECLARE_INTERFACE("82237326-8111-4f7c-bcf4-b5c1175564fe") ID2D1GdiMetafileSink : public IUnknown
{
/// <summary>
/// Callback for examining a metafile record.
/// </summary>
STDMETHOD(ProcessRecord)(
DWORD recordType,
_In_opt_ CONST void *recordData,
DWORD recordDataSize
) PURE;
}; // interface ID2D1GdiMetafileSink
/// <summary>
/// Interface encapsulating a GDI/GDI+ metafile.
/// </summary>
interface DX_DECLARE_INTERFACE("2f543dc3-cfc1-4211-864f-cfd91c6f3395") ID2D1GdiMetafile : public ID2D1Resource
{
/// <summary>
/// Play the metafile into a caller-supplied sink interface.
/// </summary>
STDMETHOD(Stream)(
_In_ ID2D1GdiMetafileSink *sink
) PURE;
/// <summary>
/// Gets the bounds of the metafile.
/// </summary>
STDMETHOD(GetBounds)(
_Out_ D2D1_RECT_F *bounds
) PURE;
}; // interface ID2D1GdiMetafile
/// <summary>
/// Caller-supplied implementation of an interface to receive the recorded command
/// list.
/// </summary>
interface DX_DECLARE_INTERFACE("54d7898a-a061-40a7-bec7-e465bcba2c4f") ID2D1CommandSink : public IUnknown
{
STDMETHOD(BeginDraw)(
) PURE;
STDMETHOD(EndDraw)(
) PURE;
STDMETHOD(SetAntialiasMode)(
D2D1_ANTIALIAS_MODE antialiasMode
) PURE;
STDMETHOD(SetTags)(
D2D1_TAG tag1,
D2D1_TAG tag2
) PURE;
STDMETHOD(SetTextAntialiasMode)(
D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode
) PURE;
STDMETHOD(SetTextRenderingParams)(
_In_opt_ IDWriteRenderingParams *textRenderingParams
) PURE;
STDMETHOD(SetTransform)(
_In_ CONST D2D1_MATRIX_3X2_F *transform
) PURE;
STDMETHOD(SetPrimitiveBlend)(
D2D1_PRIMITIVE_BLEND primitiveBlend
) PURE;
STDMETHOD(SetUnitMode)(
D2D1_UNIT_MODE unitMode
) PURE;
STDMETHOD(Clear)(
_In_opt_ CONST D2D1_COLOR_F *color
) PURE;
STDMETHOD(DrawGlyphRun)(
D2D1_POINT_2F baselineOrigin,
_In_ CONST DWRITE_GLYPH_RUN *glyphRun,
_In_opt_ CONST DWRITE_GLYPH_RUN_DESCRIPTION *glyphRunDescription,
_In_ ID2D1Brush *foregroundBrush,
DWRITE_MEASURING_MODE measuringMode
) PURE;
STDMETHOD(DrawLine)(
D2D1_POINT_2F point0,
D2D1_POINT_2F point1,
_In_ ID2D1Brush *brush,
FLOAT strokeWidth,
_In_opt_ ID2D1StrokeStyle *strokeStyle
) PURE;
STDMETHOD(DrawGeometry)(
_In_ ID2D1Geometry *geometry,
_In_ ID2D1Brush *brush,
FLOAT strokeWidth,
_In_opt_ ID2D1StrokeStyle *strokeStyle
) PURE;
STDMETHOD(DrawRectangle)(
_In_ CONST D2D1_RECT_F *rect,
_In_ ID2D1Brush *brush,
FLOAT strokeWidth,
_In_opt_ ID2D1StrokeStyle *strokeStyle
) PURE;
STDMETHOD(DrawBitmap)(
_In_ ID2D1Bitmap *bitmap,
_In_opt_ CONST D2D1_RECT_F *destinationRectangle,
FLOAT opacity,
D2D1_INTERPOLATION_MODE interpolationMode,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle,
_In_opt_ CONST D2D1_MATRIX_4X4_F *perspectiveTransform
) PURE;
STDMETHOD(DrawImage)(
_In_ ID2D1Image *image,
_In_opt_ CONST D2D1_POINT_2F *targetOffset,
_In_opt_ CONST D2D1_RECT_F *imageRectangle,
D2D1_INTERPOLATION_MODE interpolationMode,
D2D1_COMPOSITE_MODE compositeMode
) PURE;
STDMETHOD(DrawGdiMetafile)(
_In_ ID2D1GdiMetafile *gdiMetafile,
_In_opt_ CONST D2D1_POINT_2F *targetOffset
) PURE;
STDMETHOD(FillMesh)(
_In_ ID2D1Mesh *mesh,
_In_ ID2D1Brush *brush
) PURE;
STDMETHOD(FillOpacityMask)(
_In_ ID2D1Bitmap *opacityMask,
_In_ ID2D1Brush *brush,
_In_opt_ CONST D2D1_RECT_F *destinationRectangle,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle
) PURE;
STDMETHOD(FillGeometry)(
_In_ ID2D1Geometry *geometry,
_In_ ID2D1Brush *brush,
_In_opt_ ID2D1Brush *opacityBrush
) PURE;
STDMETHOD(FillRectangle)(
_In_ CONST D2D1_RECT_F *rect,
_In_ ID2D1Brush *brush
) PURE;
STDMETHOD(PushAxisAlignedClip)(
_In_ CONST D2D1_RECT_F *clipRect,
D2D1_ANTIALIAS_MODE antialiasMode
) PURE;
STDMETHOD(PushLayer)(
_In_ CONST D2D1_LAYER_PARAMETERS1 *layerParameters1,
_In_opt_ ID2D1Layer *layer
) PURE;
STDMETHOD(PopAxisAlignedClip)(
) PURE;
STDMETHOD(PopLayer)(
) PURE;
}; // interface ID2D1CommandSink
/// <summary>
/// The commandList interface.
/// </summary>
interface DX_DECLARE_INTERFACE("b4f34a19-2383-4d76-94f6-ec343657c3dc") ID2D1CommandList : public ID2D1Image
{
/// <summary>
/// Play the command list into a caller-supplied sink interface.
/// </summary>
STDMETHOD(Stream)(
_In_ ID2D1CommandSink *sink
) PURE;
/// <summary>
/// Marks the command list as ready for use.
/// </summary>
STDMETHOD(Close)(
) PURE;
}; // interface ID2D1CommandList
/// <summary>
/// Converts Direct2D primitives stored in an ID2D1CommandList into a fixed page
/// representation. The print sub-system then consumes the primitives.
/// </summary>
interface DX_DECLARE_INTERFACE("2c1d867d-c290-41c8-ae7e-34a98702e9a5") ID2D1PrintControl : public IUnknown
{
STDMETHOD(AddPage)(
_In_ ID2D1CommandList *commandList,
D2D_SIZE_F pageSize,
_In_opt_ IStream *pagePrintTicketStream,
_Out_opt_ D2D1_TAG *tag1 = NULL,
_Out_opt_ D2D1_TAG *tag2 = NULL
) PURE;
STDMETHOD(Close)(
) PURE;
}; // interface ID2D1PrintControl
/// <summary>
/// Provides a brush that can take any effect, command list or bitmap and use it to
/// fill a 2D shape.
/// </summary>
interface DX_DECLARE_INTERFACE("fe9e984d-3f95-407c-b5db-cb94d4e8f87c") ID2D1ImageBrush : public ID2D1Brush
{
STDMETHOD_(void, SetImage)(
_In_opt_ ID2D1Image *image
) PURE;
STDMETHOD_(void, SetExtendModeX)(
D2D1_EXTEND_MODE extendModeX
) PURE;
STDMETHOD_(void, SetExtendModeY)(
D2D1_EXTEND_MODE extendModeY
) PURE;
STDMETHOD_(void, SetInterpolationMode)(
D2D1_INTERPOLATION_MODE interpolationMode
) PURE;
STDMETHOD_(void, SetSourceRectangle)(
_In_ CONST D2D1_RECT_F *sourceRectangle
) PURE;
STDMETHOD_(void, GetImage)(
_Outptr_result_maybenull_ ID2D1Image **image
) CONST PURE;
STDMETHOD_(D2D1_EXTEND_MODE, GetExtendModeX)(
) CONST PURE;
STDMETHOD_(D2D1_EXTEND_MODE, GetExtendModeY)(
) CONST PURE;
STDMETHOD_(D2D1_INTERPOLATION_MODE, GetInterpolationMode)(
) CONST PURE;
STDMETHOD_(void, GetSourceRectangle)(
_Out_ D2D1_RECT_F *sourceRectangle
) CONST PURE;
}; // interface ID2D1ImageBrush
/// <summary>
/// A bitmap brush allows a bitmap to be used to fill a geometry. Interpolation
/// mode is specified with D2D1_INTERPOLATION_MODE
/// </summary>
interface DX_DECLARE_INTERFACE("41343a53-e41a-49a2-91cd-21793bbb62e5") ID2D1BitmapBrush1 : public ID2D1BitmapBrush
{
/// <summary>
/// Sets the interpolation mode used when this brush is used.
/// </summary>
STDMETHOD_(void, SetInterpolationMode1)(
D2D1_INTERPOLATION_MODE interpolationMode
) PURE;
STDMETHOD_(D2D1_INTERPOLATION_MODE, GetInterpolationMode1)(
) CONST PURE;
}; // interface ID2D1BitmapBrush1
/// <summary>
/// Extends a stroke style to allow nominal width strokes.
/// </summary>
interface DX_DECLARE_INTERFACE("10a72a66-e91c-43f4-993f-ddf4b82b0b4a") ID2D1StrokeStyle1 : public ID2D1StrokeStyle
{
STDMETHOD_(D2D1_STROKE_TRANSFORM_TYPE, GetStrokeTransformType)(
) CONST PURE;
}; // interface ID2D1StrokeStyle1
/// <summary>
/// The ID2D1PathGeometry1 interface adds functionality to ID2D1PathGeometry. In
/// particular, it provides the path geometry-specific
/// ComputePointAndSegmentAtLength method.
/// </summary>
interface DX_DECLARE_INTERFACE("62baa2d2-ab54-41b7-b872-787e0106a421") ID2D1PathGeometry1 : public ID2D1PathGeometry
{
STDMETHOD(ComputePointAndSegmentAtLength)(
FLOAT length,
UINT32 startSegment,
_In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
FLOAT flatteningTolerance,
_Out_ D2D1_POINT_DESCRIPTION *pointDescription
) CONST PURE;
COM_DECLSPEC_NOTHROW
HRESULT
ComputePointAndSegmentAtLength(
FLOAT length,
UINT32 startSegment,
CONST D2D1_MATRIX_3X2_F &worldTransform,
FLOAT flatteningTolerance,
_Out_ D2D1_POINT_DESCRIPTION *pointDescription
) CONST
{
return ComputePointAndSegmentAtLength(length, startSegment, &worldTransform, flatteningTolerance, pointDescription);
}
COM_DECLSPEC_NOTHROW
HRESULT
ComputePointAndSegmentAtLength(
FLOAT length,
UINT32 startSegment,
_In_opt_ CONST D2D1_MATRIX_3X2_F *worldTransform,
_Out_ D2D1_POINT_DESCRIPTION *pointDescription
) CONST
{
return ComputePointAndSegmentAtLength(length, startSegment, worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, pointDescription);
}
COM_DECLSPEC_NOTHROW
HRESULT
ComputePointAndSegmentAtLength(
FLOAT length,
UINT32 startSegment,
CONST D2D1_MATRIX_3X2_F &worldTransform,
_Out_ D2D1_POINT_DESCRIPTION *pointDescription
) CONST
{
return ComputePointAndSegmentAtLength(length, startSegment, &worldTransform, D2D1_DEFAULT_FLATTENING_TOLERANCE, pointDescription);
}
}; // interface ID2D1PathGeometry1
/// <summary>
/// Represents a set of run-time bindable and discoverable properties that allow a
/// data-driven application to modify the state of a Direct2D effect.
/// </summary>
interface DX_DECLARE_INTERFACE("483473d7-cd46-4f9d-9d3a-3112aa80159d") ID2D1Properties : public IUnknown
{
/// <summary>
/// Returns the total number of custom properties in this interface.
/// </summary>
STDMETHOD_(UINT32, GetPropertyCount)(
) CONST PURE;
/// <summary>
/// Retrieves the property name from the given property index.
/// </summary>
STDMETHOD(GetPropertyName)(
UINT32 index,
_Out_writes_(nameCount) PWSTR name,
UINT32 nameCount
) CONST PURE;
/// <summary>
/// Returns the length of the property name from the given index.
/// </summary>
STDMETHOD_(UINT32, GetPropertyNameLength)(
UINT32 index
) CONST PURE;
/// <summary>
/// Retrieves the type of the given property.
/// </summary>
STDMETHOD_(D2D1_PROPERTY_TYPE, GetType)(
UINT32 index
) CONST PURE;
/// <summary>
/// Retrieves the property index for the given property name.
/// </summary>
STDMETHOD_(UINT32, GetPropertyIndex)(
_In_ PCWSTR name
) CONST PURE;
/// <summary>
/// Sets the value of the given property using its name.
/// </summary>
STDMETHOD(SetValueByName)(
_In_ PCWSTR name,
D2D1_PROPERTY_TYPE type,
_In_reads_(dataSize) CONST BYTE *data,
UINT32 dataSize
) PURE;
/// <summary>
/// Sets the given value using the property index.
/// </summary>
STDMETHOD(SetValue)(
UINT32 index,
D2D1_PROPERTY_TYPE type,
_In_reads_(dataSize) CONST BYTE *data,
UINT32 dataSize
) PURE;
/// <summary>
/// Retrieves the given property or sub-property by name. '.' is the delimiter for
/// sub-properties.
/// </summary>
STDMETHOD(GetValueByName)(
_In_ PCWSTR name,
D2D1_PROPERTY_TYPE type,
_Out_writes_(dataSize) BYTE *data,
UINT32 dataSize
) CONST PURE;
/// <summary>
/// Retrieves the given value by index.
/// </summary>
STDMETHOD(GetValue)(
UINT32 index,
D2D1_PROPERTY_TYPE type,
_Out_writes_(dataSize) BYTE *data,
UINT32 dataSize
) CONST PURE;
/// <summary>
/// Returns the value size for the given property index.
/// </summary>
STDMETHOD_(UINT32, GetValueSize)(
UINT32 index
) CONST PURE;
/// <summary>
/// Retrieves the sub-properties of the given property by index.
/// </summary>
STDMETHOD(GetSubProperties)(
UINT32 index,
_COM_Outptr_result_maybenull_ ID2D1Properties **subProperties
) CONST PURE;
COM_DECLSPEC_NOTHROW
HRESULT
SetValueByName(
_In_ PCWSTR name,
_In_reads_(dataSize) CONST BYTE *data,
UINT32 dataSize
)
{
return SetValueByName(name, D2D1_PROPERTY_TYPE_UNKNOWN, data, dataSize);
}
COM_DECLSPEC_NOTHROW
HRESULT
SetValue(
UINT32 index,
_In_reads_(dataSize) CONST BYTE *data,
UINT32 dataSize
)
{
return SetValue(index, D2D1_PROPERTY_TYPE_UNKNOWN, data, dataSize);
}
COM_DECLSPEC_NOTHROW
HRESULT
GetValueByName(
_In_ PCWSTR name,
_Out_writes_(dataSize) BYTE *data,
UINT32 dataSize
) CONST
{
return GetValueByName(name, D2D1_PROPERTY_TYPE_UNKNOWN, data, dataSize);
}
COM_DECLSPEC_NOTHROW
HRESULT
GetValue(
UINT32 index,
_Out_writes_(dataSize) BYTE *data,
UINT32 dataSize
) CONST
{
return GetValue(index, D2D1_PROPERTY_TYPE_UNKNOWN, data, dataSize);
}
//
// Templatized helper functions:
//
template<typename T>
HRESULT GetValueByName(
_In_ PCWSTR propertyName,
_Out_ T *value
) const
{
return GetValueByName(propertyName, reinterpret_cast<BYTE *>(value), sizeof(*value));
}
template<typename T>
T GetValueByName(
_In_ PCWSTR propertyName
) const
{
T value;
HRESULT ignoreHr = GetValueByName(propertyName, reinterpret_cast<BYTE *>(&value), sizeof(value));
UNREFERENCED_PARAMETER(ignoreHr);
return value;
}
template<typename T>
HRESULT SetValueByName(
_In_ PCWSTR propertyName,
_In_ const T &value
)
{
return SetValueByName(propertyName, reinterpret_cast<const BYTE *>(&value), sizeof(value));
}
template<typename U>
HRESULT GetValue(
U index,
_Out_writes_(dataSize) BYTE *data,
UINT32 dataSize
) CONST
{
return GetValue(static_cast<UINT32>(index), data, dataSize);
}
template<typename T, typename U>
HRESULT GetValue(
U index,
_Out_ T *value
) const
{
return GetValue(static_cast<UINT32>(index), reinterpret_cast<BYTE *>(value), sizeof(*value));
}
template<typename T, typename U>
T GetValue(
U index
) const
{
T value;
HRESULT ignoreHr = GetValue(static_cast<UINT32>(index), reinterpret_cast<BYTE *>(&value), sizeof(value));
// Unreferenced variable:
ignoreHr;
return value;
}
template<typename U>
HRESULT SetValue(
U index,
_In_reads_(dataSize) CONST BYTE *data,
UINT32 dataSize
)
{
return SetValue(static_cast<UINT32>(index), data, dataSize);
}
template<typename T, typename U>
HRESULT SetValue(
U index,
_In_ const T &value
)
{
return SetValue(static_cast<UINT32>(index), reinterpret_cast<const BYTE *>(&value), sizeof(value));
}
template<typename U>
HRESULT GetPropertyName(
U index,
_Out_writes_(nameCount) PWSTR name,
UINT32 nameCount
) CONST
{
return GetPropertyName(static_cast<UINT32>(index), name, nameCount);
}
template<typename U>
UINT32 GetPropertyNameLength(
U index
) CONST
{
return GetPropertyNameLength(static_cast<UINT32>(index));
}
template<typename U>
D2D1_PROPERTY_TYPE GetType(
U index
) CONST
{
return GetType(static_cast<UINT32>(index));
}
template<typename U>
UINT32 GetValueSize(
U index
) CONST
{
return GetValueSize(static_cast<UINT32>(index));
}
template<typename U>
HRESULT GetSubProperties(
U index,
_Outptr_result_maybenull_ ID2D1Properties **subProperties
) CONST
{
return GetSubProperties(static_cast<UINT32>(index), subProperties);
}
}; // interface ID2D1Properties
/// <summary>
/// The effect interface. Properties control how the effect is rendered. The effect
/// is Drawn with the DrawImage call.
/// </summary>
interface DX_DECLARE_INTERFACE("28211a43-7d89-476f-8181-2d6159b220ad") ID2D1Effect : public ID2D1Properties
{
/// <summary>
/// Sets the input to the given effect. The input can be a concrete bitmap or the
/// output of another effect.
/// </summary>
STDMETHOD_(void, SetInput)(
UINT32 index,
_In_opt_ ID2D1Image *input,
BOOL invalidate = TRUE
) PURE;
/// <summary>
/// If the effect supports a variable number of inputs, this sets the number of
/// input that are currently active on the effect.
/// </summary>
STDMETHOD(SetInputCount)(
UINT32 inputCount
) PURE;
/// <summary>
/// Returns the input image to the effect. The input could be another effect or a
/// bitmap.
/// </summary>
STDMETHOD_(void, GetInput)(
UINT32 index,
_Outptr_result_maybenull_ ID2D1Image **input
) CONST PURE;
/// <summary>
/// This returns the number of input that are bound into this effect.
/// </summary>
STDMETHOD_(UINT32, GetInputCount)(
) CONST PURE;
/// <summary>
/// Returns the output image of the given effect. This can be set as the input to
/// another effect or can be drawn with DrawImage.
/// </summary>
STDMETHOD_(void, GetOutput)(
_Outptr_ ID2D1Image **outputImage
) CONST PURE;
COM_DECLSPEC_NOTHROW
void
SetInputEffect(
UINT32 index,
_In_opt_ ID2D1Effect *inputEffect,
BOOL invalidate = TRUE
)
{
ID2D1Image *output = NULL;
if (inputEffect != NULL)
{
inputEffect->GetOutput(&output);
}
SetInput(index, output, invalidate);
if (output != NULL)
{
output->Release();
}
}
}; // interface ID2D1Effect
/// <summary>
/// Represents a bitmap that can be used as a surface for an ID2D1DeviceContext or
/// mapped into system memory, and can contain additional color context information.
/// </summary>
interface DX_DECLARE_INTERFACE("a898a84c-3873-4588-b08b-ebbf978df041") ID2D1Bitmap1 : public ID2D1Bitmap
{
/// <summary>
/// Retrieves the color context information associated with the bitmap.
/// </summary>
STDMETHOD_(void, GetColorContext)(
_Outptr_result_maybenull_ ID2D1ColorContext **colorContext
) CONST PURE;
/// <summary>
/// Retrieves the bitmap options used when creating the API.
/// </summary>
STDMETHOD_(D2D1_BITMAP_OPTIONS, GetOptions)(
) CONST PURE;
/// <summary>
/// Retrieves the DXGI surface from the corresponding bitmap, if the bitmap was
/// created from a device derived from a D3D device.
/// </summary>
STDMETHOD(GetSurface)(
_COM_Outptr_result_maybenull_ IDXGISurface **dxgiSurface
) CONST PURE;
/// <summary>
/// Maps the given bitmap into memory. The bitmap must have been created with the
/// D2D1_BITMAP_OPTIONS_CPU_READ flag.
/// </summary>
STDMETHOD(Map)(
D2D1_MAP_OPTIONS options,
_Out_ D2D1_MAPPED_RECT *mappedRect
) PURE;
/// <summary>
/// Unmaps the given bitmap from memory.
/// </summary>
STDMETHOD(Unmap)(
) PURE;
}; // interface ID2D1Bitmap1
/// <summary>
/// Represents a color context that can be used with an ID2D1Bitmap1 object.
/// </summary>
interface DX_DECLARE_INTERFACE("1c4820bb-5771-4518-a581-2fe4dd0ec657") ID2D1ColorContext : public ID2D1Resource
{
/// <summary>
/// Retrieves the color space of the color context.
/// </summary>
STDMETHOD_(D2D1_COLOR_SPACE, GetColorSpace)(
) CONST PURE;
/// <summary>
/// Retrieves the size of the color profile, in bytes.
/// </summary>
STDMETHOD_(UINT32, GetProfileSize)(
) CONST PURE;
/// <summary>
/// Retrieves the color profile bytes.
/// </summary>
STDMETHOD(GetProfile)(
_Out_writes_(profileSize) BYTE *profile,
UINT32 profileSize
) CONST PURE;
}; // interface ID2D1ColorContext
/// <summary>
/// Represents an collection of gradient stops that can then be the source resource
/// for either a linear or radial gradient brush.
/// </summary>
interface DX_DECLARE_INTERFACE("ae1572f4-5dd0-4777-998b-9279472ae63b") ID2D1GradientStopCollection1 : public ID2D1GradientStopCollection
{
/// <summary>
/// Copies the gradient stops from the collection into the caller's memory. If this
/// object was created using ID2D1DeviceContext::CreateGradientStopCollection, this
/// method returns the same values as were specified in the creation method. If this
/// object was created using ID2D1RenderTarget::CreateGradientStopCollection, the
/// stops returned here will first be transformed into the gamma space specified by
/// the colorInterpolationGamma parameter.
/// </summary>
STDMETHOD_(void, GetGradientStops1)(
_Out_writes_to_(gradientStopsCount, _Inexpressible_("Retrieved through GetGradientStopCount()") ) D2D1_GRADIENT_STOP *gradientStops,
UINT32 gradientStopsCount
) CONST PURE;
/// <summary>
/// Returns the color space in which interpolation occurs. If this object was
/// created using ID2D1RenderTarget::CreateGradientStopCollection, this method
/// returns the color space related to the color interpolation gamma.
/// </summary>
STDMETHOD_(D2D1_COLOR_SPACE, GetPreInterpolationSpace)(
) CONST PURE;
/// <summary>
/// Returns the color space colors will be converted to after interpolation occurs.
/// If this object was created using
/// ID2D1RenderTarget::CreateGradientStopCollection, this method returns
/// D2D1_COLOR_SPACE_SRGB.
/// </summary>
STDMETHOD_(D2D1_COLOR_SPACE, GetPostInterpolationSpace)(
) CONST PURE;
/// <summary>
/// Returns the buffer precision of this gradient. If this object was created using
/// ID2D1RenderTarget::CreateGradientStopCollection, this method returns
/// D2D1_BUFFER_PRECISION_8BPC_UNORM.
/// </summary>
STDMETHOD_(D2D1_BUFFER_PRECISION, GetBufferPrecision)(
) CONST PURE;
/// <summary>
/// Returns the interpolation mode used to interpolate colors in the gradient.
/// </summary>
STDMETHOD_(D2D1_COLOR_INTERPOLATION_MODE, GetColorInterpolationMode)(
) CONST PURE;
}; // interface ID2D1GradientStopCollection1
/// <summary>
/// Represents drawing state.
/// </summary>
interface DX_DECLARE_INTERFACE("689f1f85-c72e-4e33-8f19-85754efd5ace") ID2D1DrawingStateBlock1 : public ID2D1DrawingStateBlock
{
/// <summary>
/// Retrieves the state currently contained within this state block resource.
/// </summary>
STDMETHOD_(void, GetDescription)(
_Out_ D2D1_DRAWING_STATE_DESCRIPTION1 *stateDescription
) CONST PURE;
using ID2D1DrawingStateBlock::GetDescription;
/// <summary>
/// Sets the state description of this state block resource.
/// </summary>
STDMETHOD_(void, SetDescription)(
_In_ CONST D2D1_DRAWING_STATE_DESCRIPTION1 *stateDescription
) PURE;
using ID2D1DrawingStateBlock::SetDescription;
}; // interface ID2D1DrawingStateBlock1
/// <summary>
/// The device context represents a set of state and a command buffer that is used
/// to render to a target bitmap.
/// </summary>
interface DX_DECLARE_INTERFACE("e8f7fe7a-191c-466d-ad95-975678bda998") ID2D1DeviceContext : public ID2D1RenderTarget
{
/// <summary>
/// Creates a bitmap with extended bitmap properties, potentially from a block of
/// memory.
/// </summary>
STDMETHOD(CreateBitmap)(
D2D1_SIZE_U size,
_In_opt_ CONST void *sourceData,
UINT32 pitch,
_In_ CONST D2D1_BITMAP_PROPERTIES1 *bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
) PURE;
using ID2D1RenderTarget::CreateBitmap;
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
STDMETHOD(CreateBitmapFromWicBitmap)(
_In_ IWICBitmapSource *wicBitmapSource,
_In_opt_ CONST D2D1_BITMAP_PROPERTIES1 *bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
) PURE;
using ID2D1RenderTarget::CreateBitmapFromWicBitmap;
/// <summary>
/// Creates a color context from a color space. If the space is Custom, the context
/// is initialized from the profile/profileSize arguments. Otherwise the context is
/// initialized with the profile bytes associated with the space and
/// profile/profileSize are ignored.
/// </summary>
STDMETHOD(CreateColorContext)(
D2D1_COLOR_SPACE space,
_In_reads_opt_(profileSize) CONST BYTE *profile,
UINT32 profileSize,
_COM_Outptr_ ID2D1ColorContext **colorContext
) PURE;
STDMETHOD(CreateColorContextFromFilename)(
_In_ PCWSTR filename,
_COM_Outptr_ ID2D1ColorContext **colorContext
) PURE;
STDMETHOD(CreateColorContextFromWicColorContext)(
_In_ IWICColorContext *wicColorContext,
_COM_Outptr_ ID2D1ColorContext **colorContext
) PURE;
/// <summary>
/// Creates a bitmap from a DXGI surface with a set of extended properties.
/// </summary>
STDMETHOD(CreateBitmapFromDxgiSurface)(
_In_ IDXGISurface *surface,
_In_opt_ CONST D2D1_BITMAP_PROPERTIES1 *bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
) PURE;
/// <summary>
/// Create a new effect, the effect must either be built in or previously registered
/// through ID2D1Factory1::RegisterEffectFromStream or
/// ID2D1Factory1::RegisterEffectFromString.
/// </summary>
STDMETHOD(CreateEffect)(
_In_ REFCLSID effectId,
_COM_Outptr_ ID2D1Effect **effect
) PURE;
/// <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="preInterpolationSpace">Specifies both the input color space and the
/// space in which the color interpolation occurs.</param>
/// <param name="postInterpolationSpace">Specifies the color space colors will be
/// converted to after interpolation occurs.</param>
/// <param name="bufferPrecision">Specifies the precision in which the gradient
/// buffer will be held.</param>
/// <param name="extendMode">Specifies how the gradient will be extended outside of
/// the unit length.</param>
/// <param name="colorInterpolationMode">Determines if colors will be interpolated
/// in straight alpha or premultiplied alpha space.</param>
STDMETHOD(CreateGradientStopCollection)(
_In_reads_(straightAlphaGradientStopsCount) CONST D2D1_GRADIENT_STOP *straightAlphaGradientStops,
_In_range_(>=,1) UINT32 straightAlphaGradientStopsCount,
D2D1_COLOR_SPACE preInterpolationSpace,
D2D1_COLOR_SPACE postInterpolationSpace,
D2D1_BUFFER_PRECISION bufferPrecision,
D2D1_EXTEND_MODE extendMode,
D2D1_COLOR_INTERPOLATION_MODE colorInterpolationMode,
_COM_Outptr_ ID2D1GradientStopCollection1 **gradientStopCollection1
) PURE;
using ID2D1RenderTarget::CreateGradientStopCollection;
/// <summary>
/// Creates an image brush, the input image can be any type of image, including a
/// bitmap, effect and a command list.
/// </summary>
STDMETHOD(CreateImageBrush)(
_In_opt_ ID2D1Image *image,
_In_ CONST D2D1_IMAGE_BRUSH_PROPERTIES *imageBrushProperties,
_In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
_COM_Outptr_ ID2D1ImageBrush **imageBrush
) PURE;
STDMETHOD(CreateBitmapBrush)(
_In_opt_ ID2D1Bitmap *bitmap,
_In_opt_ CONST D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmapBrushProperties,
_In_opt_ CONST D2D1_BRUSH_PROPERTIES *brushProperties,
_COM_Outptr_ ID2D1BitmapBrush1 **bitmapBrush
) PURE;
using ID2D1RenderTarget::CreateBitmapBrush;
/// <summary>
/// Creates a new command list.
/// </summary>
STDMETHOD(CreateCommandList)(
_COM_Outptr_ ID2D1CommandList **commandList
) PURE;
/// <summary>
/// Indicates whether the format is supported by D2D.
/// </summary>
STDMETHOD_(BOOL, IsDxgiFormatSupported)(
DXGI_FORMAT format
) CONST PURE;
/// <summary>
/// Indicates whether the buffer precision is supported by D2D.
/// </summary>
STDMETHOD_(BOOL, IsBufferPrecisionSupported)(
D2D1_BUFFER_PRECISION bufferPrecision
) CONST PURE;
/// <summary>
/// This retrieves the local-space bounds in DIPs of the current image using the
/// device context DPI.
/// </summary>
STDMETHOD(GetImageLocalBounds)(
_In_ ID2D1Image *image,
_Out_ D2D1_RECT_F *localBounds
) CONST PURE;
/// <summary>
/// This retrieves the world-space bounds in DIPs of the current image using the
/// device context DPI.
/// </summary>
STDMETHOD(GetImageWorldBounds)(
_In_ ID2D1Image *image,
_Out_ D2D1_RECT_F *worldBounds
) CONST PURE;
/// <summary>
/// Retrieves the world-space bounds in DIPs of the glyph run using the device
/// context DPI.
/// </summary>
STDMETHOD(GetGlyphRunWorldBounds)(
D2D1_POINT_2F baselineOrigin,
_In_ CONST DWRITE_GLYPH_RUN *glyphRun,
DWRITE_MEASURING_MODE measuringMode,
_Out_ D2D1_RECT_F *bounds
) CONST PURE;
/// <summary>
/// Retrieves the device associated with this device context.
/// </summary>
STDMETHOD_(void, GetDevice)(
_Outptr_ ID2D1Device **device
) CONST PURE;
/// <summary>
/// Sets the target for this device context to point to the given image. The image
/// can be a command list or a bitmap created with the D2D1_BITMAP_OPTIONS_TARGET
/// flag.
/// </summary>
STDMETHOD_(void, SetTarget)(
_In_opt_ ID2D1Image *image
) PURE;
/// <summary>
/// Gets the target that this device context is currently pointing to.
/// </summary>
STDMETHOD_(void, GetTarget)(
_Outptr_result_maybenull_ ID2D1Image **image
) CONST PURE;
/// <summary>
/// Sets tuning parameters for internal rendering inside the device context.
/// </summary>
STDMETHOD_(void, SetRenderingControls)(
_In_ CONST D2D1_RENDERING_CONTROLS *renderingControls
) PURE;
/// <summary>
/// This retrieves the rendering controls currently selected into the device
/// context.
/// </summary>
STDMETHOD_(void, GetRenderingControls)(
_Out_ D2D1_RENDERING_CONTROLS *renderingControls
) CONST PURE;
/// <summary>
/// Changes the primitive blending mode for all of the rendering operations.
/// </summary>
STDMETHOD_(void, SetPrimitiveBlend)(
D2D1_PRIMITIVE_BLEND primitiveBlend
) PURE;
/// <summary>
/// Returns the primitive blend currently selected into the device context.
/// </summary>
STDMETHOD_(D2D1_PRIMITIVE_BLEND, GetPrimitiveBlend)(
) CONST PURE;
/// <summary>
/// Changes the units used for all of the rendering operations.
/// </summary>
STDMETHOD_(void, SetUnitMode)(
D2D1_UNIT_MODE unitMode
) PURE;
/// <summary>
/// Returns the unit mode currently set on the device context.
/// </summary>
STDMETHOD_(D2D1_UNIT_MODE, GetUnitMode)(
) CONST PURE;
/// <summary>
/// Draws the glyph run with an extended description to describe the glyphs.
/// </summary>
STDMETHOD_(void, DrawGlyphRun)(
D2D1_POINT_2F baselineOrigin,
_In_ CONST DWRITE_GLYPH_RUN *glyphRun,
_In_opt_ CONST DWRITE_GLYPH_RUN_DESCRIPTION *glyphRunDescription,
_In_ ID2D1Brush *foregroundBrush,
DWRITE_MEASURING_MODE measuringMode = DWRITE_MEASURING_MODE_NATURAL
) PURE;
using ID2D1RenderTarget::DrawGlyphRun;
/// <summary>
/// Draw an image to the device context. The image represents either a concrete
/// bitmap or the output of an effect graph.
/// </summary>
STDMETHOD_(void, DrawImage)(
_In_ ID2D1Image *image,
_In_opt_ CONST D2D1_POINT_2F *targetOffset = NULL,
_In_opt_ CONST D2D1_RECT_F *imageRectangle = NULL,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
) PURE;
/// <summary>
/// Draw a metafile to the device context.
/// </summary>
STDMETHOD_(void, DrawGdiMetafile)(
_In_ ID2D1GdiMetafile *gdiMetafile,
_In_opt_ CONST D2D1_POINT_2F *targetOffset = NULL
) PURE;
STDMETHOD_(void, DrawBitmap)(
_In_ ID2D1Bitmap *bitmap,
_In_opt_ CONST D2D1_RECT_F *destinationRectangle,
FLOAT opacity,
D2D1_INTERPOLATION_MODE interpolationMode,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL,
_In_opt_ CONST D2D1_MATRIX_4X4_F *perspectiveTransform = NULL
) PURE;
using ID2D1RenderTarget::DrawBitmap;
/// <summary>
/// Push a layer on the device context.
/// </summary>
STDMETHOD_(void, PushLayer)(
_In_ CONST D2D1_LAYER_PARAMETERS1 *layerParameters,
_In_opt_ ID2D1Layer *layer
) PURE;
using ID2D1RenderTarget::PushLayer;
/// <summary>
/// This indicates that a portion of an effect's input is invalid. This method can
/// be called many times.
/// </summary>
STDMETHOD(InvalidateEffectInputRectangle)(
_In_ ID2D1Effect *effect,
UINT32 input,
_In_ CONST D2D1_RECT_F *inputRectangle
) PURE;
/// <summary>
/// Gets the number of invalid ouptut rectangles that have accumulated at the
/// effect.
/// </summary>
STDMETHOD(GetEffectInvalidRectangleCount)(
_In_ ID2D1Effect *effect,
_Out_ UINT32 *rectangleCount
) PURE;
/// <summary>
/// Gets the invalid rectangles that are at the output of the effect.
/// </summary>
STDMETHOD(GetEffectInvalidRectangles)(
_In_ ID2D1Effect *effect,
_Out_writes_(rectanglesCount) D2D1_RECT_F *rectangles,
UINT32 rectanglesCount
) PURE;
/// <summary>
/// Gets the maximum region of each specified input which would be used during a
/// subsequent rendering operation
/// </summary>
STDMETHOD(GetEffectRequiredInputRectangles)(
_In_ ID2D1Effect *renderEffect,
_In_opt_ CONST D2D1_RECT_F *renderImageRectangle,
_In_reads_(inputCount) CONST D2D1_EFFECT_INPUT_DESCRIPTION *inputDescriptions,
_Out_writes_(inputCount) D2D1_RECT_F *requiredInputRects,
UINT32 inputCount
) PURE;
/// <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>
STDMETHOD_(void, FillOpacityMask)(
_In_ ID2D1Bitmap *opacityMask,
_In_ ID2D1Brush *brush,
_In_opt_ CONST D2D1_RECT_F *destinationRectangle = NULL,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL
) PURE;
using ID2D1RenderTarget::FillOpacityMask;
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmap(
D2D1_SIZE_U size,
_In_opt_ CONST void *sourceData,
UINT32 pitch,
CONST D2D1_BITMAP_PROPERTIES1 &bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
)
{
return CreateBitmap(size, sourceData, pitch, &bitmapProperties, bitmap);
}
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapFromWicBitmap(
_In_ IWICBitmapSource *wicBitmapSource,
CONST D2D1_BITMAP_PROPERTIES1 &bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
)
{
return CreateBitmapFromWicBitmap(wicBitmapSource, &bitmapProperties, bitmap);
}
/// <summary>
/// Create a D2D bitmap by copying a WIC bitmap.
/// </summary>
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapFromWicBitmap(
_In_ IWICBitmapSource *wicBitmapSource,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
)
{
return CreateBitmapFromWicBitmap(wicBitmapSource, NULL, bitmap);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapFromDxgiSurface(
_In_ IDXGISurface *surface,
CONST D2D1_BITMAP_PROPERTIES1 &bitmapProperties,
_COM_Outptr_ ID2D1Bitmap1 **bitmap
)
{
return CreateBitmapFromDxgiSurface(surface, &bitmapProperties, bitmap);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateImageBrush(
_In_opt_ ID2D1Image *image,
CONST D2D1_IMAGE_BRUSH_PROPERTIES &imageBrushProperties,
CONST D2D1_BRUSH_PROPERTIES &brushProperties,
_COM_Outptr_ ID2D1ImageBrush **imageBrush
)
{
return CreateImageBrush(image, &imageBrushProperties, &brushProperties, imageBrush);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateImageBrush(
_In_opt_ ID2D1Image *image,
CONST D2D1_IMAGE_BRUSH_PROPERTIES &imageBrushProperties,
_COM_Outptr_ ID2D1ImageBrush **imageBrush
)
{
return CreateImageBrush(image,&imageBrushProperties, NULL, imageBrush);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapBrush(
_In_opt_ ID2D1Bitmap *bitmap,
_COM_Outptr_ ID2D1BitmapBrush1 **bitmapBrush
)
{
return CreateBitmapBrush(bitmap, NULL, NULL, bitmapBrush);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapBrush(
_In_opt_ ID2D1Bitmap *bitmap,
CONST D2D1_BITMAP_BRUSH_PROPERTIES1 &bitmapBrushProperties,
_COM_Outptr_ ID2D1BitmapBrush1 **bitmapBrush
)
{
return CreateBitmapBrush(bitmap, &bitmapBrushProperties, NULL, bitmapBrush);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateBitmapBrush(
_In_opt_ ID2D1Bitmap *bitmap,
CONST D2D1_BITMAP_BRUSH_PROPERTIES1 &bitmapBrushProperties,
CONST D2D1_BRUSH_PROPERTIES &brushProperties,
_COM_Outptr_ ID2D1BitmapBrush1 **bitmapBrush
)
{
return CreateBitmapBrush(bitmap, &bitmapBrushProperties, &brushProperties, bitmapBrush);
}
/// <summary>
/// Draws the output of the effect as an image.
/// </summary>
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Effect *effect,
_In_opt_ CONST D2D1_POINT_2F *targetOffset = NULL,
_In_opt_ CONST D2D1_RECT_F *imageRectangle = NULL,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
ID2D1Image *output = NULL;
effect->GetOutput(&output);
DrawImage(output, targetOffset, imageRectangle, interpolationMode, compositeMode);
output->Release();
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Image *image,
D2D1_INTERPOLATION_MODE interpolationMode,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(image, NULL, NULL, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Effect *effect,
D2D1_INTERPOLATION_MODE interpolationMode,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(effect, NULL, NULL, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Image *image,
D2D1_POINT_2F targetOffset,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(image, &targetOffset, NULL, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Effect *effect,
D2D1_POINT_2F targetOffset,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(effect, &targetOffset, NULL, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Image *image,
D2D1_POINT_2F targetOffset,
CONST D2D1_RECT_F &imageRectangle,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(image, &targetOffset, &imageRectangle, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
DrawImage(
_In_ ID2D1Effect *effect,
D2D1_POINT_2F targetOffset,
CONST D2D1_RECT_F &imageRectangle,
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
D2D1_COMPOSITE_MODE compositeMode = D2D1_COMPOSITE_MODE_SOURCE_OVER
)
{
DrawImage(effect, &targetOffset, &imageRectangle, interpolationMode, compositeMode);
}
COM_DECLSPEC_NOTHROW
void
PushLayer(
CONST D2D1_LAYER_PARAMETERS1 &layerParameters,
_In_opt_ ID2D1Layer *layer
)
{
PushLayer(&layerParameters, layer);
}
COM_DECLSPEC_NOTHROW
void
DrawGdiMetafile(
_In_ ID2D1GdiMetafile *gdiMetafile,
D2D1_POINT_2F targetOffset
)
{
DrawGdiMetafile(gdiMetafile, &targetOffset);
}
COM_DECLSPEC_NOTHROW
void
DrawBitmap(
_In_ ID2D1Bitmap *bitmap,
CONST D2D1_RECT_F &destinationRectangle,
FLOAT opacity,
D2D1_INTERPOLATION_MODE interpolationMode,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL,
_In_opt_ CONST D2D1_MATRIX_4X4_F *perspectiveTransform = NULL
)
{
DrawBitmap(bitmap, &destinationRectangle, opacity, interpolationMode, sourceRectangle, perspectiveTransform);
}
COM_DECLSPEC_NOTHROW
void
DrawBitmap(
_In_ ID2D1Bitmap *bitmap,
CONST D2D1_RECT_F &destinationRectangle,
FLOAT opacity,
D2D1_INTERPOLATION_MODE interpolationMode,
CONST D2D1_RECT_F &sourceRectangle,
_In_opt_ CONST D2D1_MATRIX_4X4_F *perspectiveTransform = NULL
)
{
DrawBitmap(bitmap, &destinationRectangle, opacity, interpolationMode, &sourceRectangle, perspectiveTransform);
}
COM_DECLSPEC_NOTHROW
void
DrawBitmap(
_In_ ID2D1Bitmap *bitmap,
CONST D2D1_RECT_F &destinationRectangle,
FLOAT opacity,
D2D1_INTERPOLATION_MODE interpolationMode,
CONST D2D1_RECT_F &sourceRectangle,
CONST D2D1_MATRIX_4X4_F &perspectiveTransform
)
{
DrawBitmap(bitmap, &destinationRectangle, opacity, interpolationMode, &sourceRectangle, &perspectiveTransform);
}
COM_DECLSPEC_NOTHROW
void
FillOpacityMask(
_In_ ID2D1Bitmap *opacityMask,
_In_ ID2D1Brush *brush,
CONST D2D1_RECT_F &destinationRectangle,
_In_opt_ CONST D2D1_RECT_F *sourceRectangle = NULL
)
{
FillOpacityMask(opacityMask, brush, &destinationRectangle, sourceRectangle);
}
COM_DECLSPEC_NOTHROW
void
FillOpacityMask(
_In_ ID2D1Bitmap *opacityMask,
_In_ ID2D1Brush *brush,
CONST D2D1_RECT_F &destinationRectangle,
CONST D2D1_RECT_F &sourceRectangle
)
{
FillOpacityMask(opacityMask, brush, &destinationRectangle, &sourceRectangle);
}
/// <summary>
/// Sets tuning parameters for internal rendering inside the device context.
/// </summary>
COM_DECLSPEC_NOTHROW
void
SetRenderingControls(
CONST D2D1_RENDERING_CONTROLS &renderingControls
)
{
return SetRenderingControls(&renderingControls);
}
}; // interface ID2D1DeviceContext
/// <summary>
/// The device defines a resource domain whose objects and device contexts can be
/// used together.
/// </summary>
interface DX_DECLARE_INTERFACE("47dd575d-ac05-4cdd-8049-9b02cd16f44c") ID2D1Device : public ID2D1Resource
{
/// <summary>
/// Creates a new device context with no initially assigned target.
/// </summary>
STDMETHOD(CreateDeviceContext)(
D2D1_DEVICE_CONTEXT_OPTIONS options,
_COM_Outptr_ ID2D1DeviceContext **deviceContext
) PURE;
/// <summary>
/// Creates a D2D print control.
/// </summary>
STDMETHOD(CreatePrintControl)(
_In_ IWICImagingFactory *wicFactory,
_In_ IPrintDocumentPackageTarget *documentTarget,
_In_opt_ CONST D2D1_PRINT_CONTROL_PROPERTIES *printControlProperties,
_COM_Outptr_ ID2D1PrintControl **printControl
) PURE;
/// <summary>
/// Sets the maximum amount of texture memory to maintain before evicting caches.
/// </summary>
STDMETHOD_(void, SetMaximumTextureMemory)(
UINT64 maximumInBytes
) PURE;
/// <summary>
/// Gets the maximum amount of texture memory to maintain before evicting caches.
/// </summary>
STDMETHOD_(UINT64, GetMaximumTextureMemory)(
) CONST PURE;
/// <summary>
/// Clears all resources that are cached but not held in use by the application
/// through an interface reference.
/// </summary>
STDMETHOD_(void, ClearResources)(
UINT32 millisecondsSinceUse = 0
) PURE;
COM_DECLSPEC_NOTHROW
HRESULT
CreatePrintControl(
_In_ IWICImagingFactory *wicFactory,
_In_ IPrintDocumentPackageTarget *documentTarget,
CONST D2D1_PRINT_CONTROL_PROPERTIES &printControlProperties,
_COM_Outptr_ ID2D1PrintControl **printControl
)
{
return CreatePrintControl(wicFactory, documentTarget, &printControlProperties, printControl);
}
}; // interface ID2D1Device
/// <summary>
/// Creates Direct2D resources.
/// </summary>
interface DX_DECLARE_INTERFACE("bb12d362-daee-4b9a-aa1d-14ba401cfa1f") ID2D1Factory1 : public ID2D1Factory
{
/// <summary>
/// This creates a new Direct2D device from the given IDXGIDevice.
/// </summary>
STDMETHOD(CreateDevice)(
_In_ IDXGIDevice *dxgiDevice,
_COM_Outptr_ ID2D1Device **d2dDevice
) PURE;
/// <summary>
/// This creates a stroke style with the ability to preserve stroke width in various
/// ways.
/// </summary>
STDMETHOD(CreateStrokeStyle)(
_In_ CONST D2D1_STROKE_STYLE_PROPERTIES1 *strokeStyleProperties,
_In_reads_opt_(dashesCount) CONST FLOAT *dashes,
UINT32 dashesCount,
_COM_Outptr_ ID2D1StrokeStyle1 **strokeStyle
) PURE;
using ID2D1Factory::CreateStrokeStyle;
/// <summary>
/// Creates a path geometry with new operational methods.
/// </summary>
STDMETHOD(CreatePathGeometry)(
_COM_Outptr_ ID2D1PathGeometry1 **pathGeometry
) PURE;
using ID2D1Factory::CreatePathGeometry;
/// <summary>
/// Creates a new drawing state block, this can be used in subsequent
/// SaveDrawingState and RestoreDrawingState operations on the render target.
/// </summary>
STDMETHOD(CreateDrawingStateBlock)(
_In_opt_ CONST D2D1_DRAWING_STATE_DESCRIPTION1 *drawingStateDescription,
_In_opt_ IDWriteRenderingParams *textRenderingParams,
_COM_Outptr_ ID2D1DrawingStateBlock1 **drawingStateBlock
) PURE;
using ID2D1Factory::CreateDrawingStateBlock;
/// <summary>
/// Creates a new GDI metafile.
/// </summary>
STDMETHOD(CreateGdiMetafile)(
_In_ IStream *metafileStream,
_COM_Outptr_ ID2D1GdiMetafile **metafile
) PURE;
/// <summary>
/// This globally registers the given effect. The effect can later be instantiated
/// by using the registered class id. The effect registration is reference counted.
/// </summary>
STDMETHOD(RegisterEffectFromStream)(
_In_ REFCLSID classId,
_In_ IStream *propertyXml,
_In_reads_opt_(bindingsCount) CONST D2D1_PROPERTY_BINDING *bindings,
UINT32 bindingsCount,
_In_ CONST PD2D1_EFFECT_FACTORY effectFactory
) PURE;
/// <summary>
/// This globally registers the given effect. The effect can later be instantiated
/// by using the registered class id. The effect registration is reference counted.
/// </summary>
STDMETHOD(RegisterEffectFromString)(
_In_ REFCLSID classId,
_In_ PCWSTR propertyXml,
_In_reads_opt_(bindingsCount) CONST D2D1_PROPERTY_BINDING *bindings,
UINT32 bindingsCount,
_In_ CONST PD2D1_EFFECT_FACTORY effectFactory
) PURE;
/// <summary>
/// This unregisters the given effect by its class id, you need to call
/// UnregisterEffect for every call to ID2D1Factory1::RegisterEffectFromStream and
/// ID2D1Factory1::RegisterEffectFromString to completely unregister it.
/// </summary>
STDMETHOD(UnregisterEffect)(
_In_ REFCLSID classId
) PURE;
/// <summary>
/// This returns all of the registered effects in the process, including any
/// built-in effects.
/// </summary>
/// <param name="effectsReturned">The number of effects returned into the passed in
/// effects array.</param>
/// <param name="effectsRegistered">The number of effects currently registered in
/// the system.</param>
STDMETHOD(GetRegisteredEffects)(
_Out_writes_to_opt_(effectsCount, *effectsReturned) CLSID *effects,
UINT32 effectsCount,
_Out_opt_ UINT32 *effectsReturned,
_Out_opt_ UINT32 *effectsRegistered
) CONST PURE;
/// <summary>
/// This retrieves the effect properties for the given effect, all of the effect
/// properties will be set to a default value since an effect is not instantiated to
/// implement the returned property interface.
/// </summary>
STDMETHOD(GetEffectProperties)(
_In_ REFCLSID effectId,
_COM_Outptr_ ID2D1Properties **properties
) CONST PURE;
COM_DECLSPEC_NOTHROW
HRESULT
CreateStrokeStyle(
CONST D2D1_STROKE_STYLE_PROPERTIES1 &strokeStyleProperties,
_In_reads_opt_(dashesCount) CONST FLOAT *dashes,
UINT32 dashesCount,
_COM_Outptr_ ID2D1StrokeStyle1 **strokeStyle
)
{
return CreateStrokeStyle(&strokeStyleProperties, dashes, dashesCount, strokeStyle);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateDrawingStateBlock(
CONST D2D1_DRAWING_STATE_DESCRIPTION1 &drawingStateDescription,
_COM_Outptr_ ID2D1DrawingStateBlock1 **drawingStateBlock
)
{
return CreateDrawingStateBlock(&drawingStateDescription, NULL, drawingStateBlock);
}
COM_DECLSPEC_NOTHROW
HRESULT
CreateDrawingStateBlock(
_COM_Outptr_ ID2D1DrawingStateBlock1 **drawingStateBlock
)
{
return CreateDrawingStateBlock(NULL, NULL, drawingStateBlock);
}
}; // interface ID2D1Factory1
/// <summary>
/// A locking mechanism from a Direct2D factory that Direct2D uses to control
/// exclusive resource access in an app that is uses multiple threads.
/// </summary>
interface DX_DECLARE_INTERFACE("31e6e7bc-e0ff-4d46-8c64-a0a8c41c15d3") ID2D1Multithread : public IUnknown
{
/// <summary>
/// Returns whether the D2D factory was created with
/// D2D1_FACTORY_TYPE_MULTI_THREADED.
/// </summary>
STDMETHOD_(BOOL, GetMultithreadProtected)(
) CONST PURE;
/// <summary>
/// Enters the D2D API critical section, if it exists.
/// </summary>
STDMETHOD_(void, Enter)(
) PURE;
/// <summary>
/// Leaves the D2D API critical section, if it exists.
/// </summary>
STDMETHOD_(void, Leave)(
) PURE;
}; // interface ID2D1Multithread
#endif
#ifdef D2D_USE_C_DEFINITIONS
typedef interface ID2D1GdiMetafileSink ID2D1GdiMetafileSink;
typedef interface ID2D1GdiMetafile ID2D1GdiMetafile;
typedef interface ID2D1CommandSink ID2D1CommandSink;
typedef interface ID2D1CommandList ID2D1CommandList;
typedef interface ID2D1PrintControl ID2D1PrintControl;
typedef interface ID2D1ImageBrush ID2D1ImageBrush;
typedef interface ID2D1BitmapBrush1 ID2D1BitmapBrush1;
typedef interface ID2D1StrokeStyle1 ID2D1StrokeStyle1;
typedef interface ID2D1PathGeometry1 ID2D1PathGeometry1;
typedef interface ID2D1Properties ID2D1Properties;
typedef interface ID2D1Effect ID2D1Effect;
typedef interface ID2D1Bitmap1 ID2D1Bitmap1;
typedef interface ID2D1ColorContext ID2D1ColorContext;
typedef interface ID2D1GradientStopCollection1 ID2D1GradientStopCollection1;
typedef interface ID2D1DrawingStateBlock1 ID2D1DrawingStateBlock1;
typedef interface ID2D1DeviceContext ID2D1DeviceContext;
typedef interface ID2D1Device ID2D1Device;
typedef interface ID2D1Factory1 ID2D1Factory1;
typedef interface ID2D1Multithread ID2D1Multithread;
#endif
#ifdef __cplusplus
extern "C"
{
#endif
HRESULT WINAPI
D2D1CreateDevice(
_In_ IDXGIDevice *dxgiDevice,
_In_opt_ CONST D2D1_CREATION_PROPERTIES *creationProperties,
_Outptr_ ID2D1Device **d2dDevice
);
HRESULT WINAPI
D2D1CreateDeviceContext(
_In_ IDXGISurface *dxgiSurface,
_In_opt_ CONST D2D1_CREATION_PROPERTIES *creationProperties,
_Outptr_ ID2D1DeviceContext **d2dDeviceContext
);
D2D1_COLOR_F WINAPI
D2D1ConvertColorSpace(
D2D1_COLOR_SPACE sourceColorSpace,
D2D1_COLOR_SPACE destinationColorSpace,
_In_ CONST D2D1_COLOR_F* color
);
void WINAPI
D2D1SinCos(
_In_ FLOAT angle,
_Out_ FLOAT *s,
_Out_ FLOAT *c
);
FLOAT WINAPI
D2D1Tan(
_In_ FLOAT angle
);
FLOAT WINAPI
D2D1Vec3Length(
_In_ FLOAT x,
_In_ FLOAT y,
_In_ FLOAT z
);
#ifdef __cplusplus
}
#endif
#include <d2d1_1helper.h>
#ifndef D2D_USE_C_DEFINITIONS
inline HRESULT
D2D1CreateDevice(
_In_ IDXGIDevice *dxgiDevice,
_In_ CONST D2D1_CREATION_PROPERTIES &creationProperties,
_Outptr_ ID2D1Device **d2dDevice
)
{
return
D2D1CreateDevice(
dxgiDevice,
&creationProperties,
d2dDevice);
}
inline HRESULT
D2D1CreateDeviceContext(
_In_ IDXGISurface *dxgiSurface,
_In_ CONST D2D1_CREATION_PROPERTIES &creationProperties,
_Outptr_ ID2D1DeviceContext **d2dDeviceContext
)
{
return
D2D1CreateDeviceContext(
dxgiSurface,
&creationProperties,
d2dDeviceContext);
}
#endif // #ifndef D2D_USE_C_DEFINITIONS
/*#endif*/ /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
/*#pragma endregion*/
#endif // #ifndef _D2D1_1_H_
Reference in New Issue View Git Blame Copy Permalink