Subversion Repositories Games.Chess Giants

//---------------------------------------------------------------------------

// Copyright (c) Microsoft Corporation.  All rights reserved.

//

// This file is automatically generated.  Please do not edit it directly.

//

// File name: D2D1.h

//---------------------------------------------------------------------------

#pragma once

#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>

#ifndef D2D_NO_INCLUDE_D3D10

#include <d3d10_1.h>

#endif // #ifndef D2D_NO_INCLUDE_D3D10

#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

#ifndef D2D1_DECLARE_INTERFACE

#define D2D1_DECLARE_INTERFACE(X) DECLSPEC_UUID(X) DECLSPEC_NOVTABLE

#endif

//

// Forward declarations here

//

typedef interface IDWriteTextFormat IDWriteTextFormat;

typedef interface IDWriteTextLayout IDWriteTextLayout;

typedef interface IDWriteRenderingParams IDWriteRenderingParams;

typedef interface IDXGISurface IDXGISurface;

typedef interface IWICBitmap IWICBitmap;

typedef interface IWICBitmapSource IWICBitmapSource;

typedef struct DWRITE_GLYPH_RUN DWRITE_GLYPH_RUN;

#ifndef D2D_USE_C_DEFINITIONS

interface ID2D1Factory;

interface ID2D1RenderTarget;

interface ID2D1BitmapRenderTarget;

interface ID2D1SimplifiedGeometrySink;

interface ID2D1TessellationSink;

interface ID2D1Geometry;

interface ID2D1Brush;

#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)

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_ALPHA_MODE

//

//  Synopsis:

//      Qualifies how alpha is to be treated in a bitmap or render target containing

//      alpha.

//

//------------------------------------------------------------------------------

typedef enum D2D1_ALPHA_MODE

{

        //

        // Alpha mode should be determined implicitly. Some target surfaces do not supply

        // or imply this information in which case alpha must be specified.

        //

        D2D1_ALPHA_MODE_UNKNOWN = 0,

        //

        // Treat the alpha as premultipled.

        //

        D2D1_ALPHA_MODE_PREMULTIPLIED = 1,

        //

        // Opacity is in the 'A' component only.

        //

        D2D1_ALPHA_MODE_STRAIGHT = 2,

        //

        // Ignore any alpha channel information.

        //

        D2D1_ALPHA_MODE_IGNORE = 3,

        D2D1_ALPHA_MODE_FORCE_DWORD = 0xffffffff

} D2D1_ALPHA_MODE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_GAMMA

//

//  Synopsis:

//      This determines what gamma is used for interpolation/blending.

//

//------------------------------------------------------------------------------

typedef enum D2D1_GAMMA

{

        //

        // Colors are manipulated in 2.2 gamma color space.

        //

        D2D1_GAMMA_2_2 = 0,

        //

        // Colors are manipulated in 1.0 gamma color space.

        //

        D2D1_GAMMA_1_0 = 1,

        D2D1_GAMMA_FORCE_DWORD = 0xffffffff

} D2D1_GAMMA;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_OPACITY_MASK_CONTENT

//

//  Synopsis:

//      Specifies what the contents are of an opacity mask.

//

//------------------------------------------------------------------------------

typedef enum D2D1_OPACITY_MASK_CONTENT

{

        //

        // The mask contains geometries or bitmaps.

        //

        D2D1_OPACITY_MASK_CONTENT_GRAPHICS = 0,

        //

        // The mask contains text rendered using one of the natural text modes.

        //

        D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = 1,

        //

        // The mask contains text rendered using one of the GDI compatible text modes.

        //

        D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = 2,

        D2D1_OPACITY_MASK_CONTENT_FORCE_DWORD = 0xffffffff

} D2D1_OPACITY_MASK_CONTENT;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_EXTEND_MODE

//

//  Synopsis:

//      Enum which descibes how to sample from a source outside it's base tile.

//

//------------------------------------------------------------------------------

typedef enum D2D1_EXTEND_MODE

{

        //

        // Extend the edges of the source out by clamping sample points outside the source

        // to the edges.

        //

        D2D1_EXTEND_MODE_CLAMP = 0,

        //

        // The base tile is drawn untransformed and the remainder are filled by repeating

        // the base tile.

        //

        D2D1_EXTEND_MODE_WRAP = 1,

        //

        // The same as wrap, but alternate tiles are flipped  The base tile is drawn

        // untransformed.

        //

        D2D1_EXTEND_MODE_MIRROR = 2,

        D2D1_EXTEND_MODE_FORCE_DWORD = 0xffffffff

} D2D1_EXTEND_MODE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_ANTIALIAS_MODE

//

//  Synopsis:

//      Enum which descibes the manner in which we render edges of non-text primitives.

//

//------------------------------------------------------------------------------

typedef enum D2D1_ANTIALIAS_MODE

{

        //

        // The edges of each primitive are antialiased sequentially.

        //

        D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = 0,

        //

        // Each pixel is rendered if its pixel center is contained by the geometry.

        //

        D2D1_ANTIALIAS_MODE_ALIASED = 1,

        D2D1_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

} D2D1_ANTIALIAS_MODE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_TEXT_ANTIALIAS_MODE

//

//------------------------------------------------------------------------------

typedef enum D2D1_TEXT_ANTIALIAS_MODE

{

        //

        // Render text using the current system setting.

        //

        D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = 0,

        //

        // Render text using ClearType.

        //

        D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = 1,

        //

        // Render text using gray-scale.

        //

        D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = 2,

        //

        // Render text aliased.

        //

        D2D1_TEXT_ANTIALIAS_MODE_ALIASED = 3,

        D2D1_TEXT_ANTIALIAS_MODE_FORCE_DWORD = 0xffffffff

} D2D1_TEXT_ANTIALIAS_MODE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_BITMAP_INTERPOLATION_MODE

//

//------------------------------------------------------------------------------

typedef enum D2D1_BITMAP_INTERPOLATION_MODE

{

        //

        // Nearest Neighbor filtering. Also known as nearest pixel or nearest point

        // sampling.

        //

        D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = 0,

        //

        // Linear filtering.

        //

        D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = 1,

        D2D1_BITMAP_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff

} D2D1_BITMAP_INTERPOLATION_MODE;

//+-----------------------------------------------------------------------------

//

//  Flag:

//      D2D1_DRAW_TEXT_OPTIONS

//

//  Synopsis:

//      Modifications made to the draw text call that influence how the text is

//      rendered.

//

//------------------------------------------------------------------------------

typedef enum D2D1_DRAW_TEXT_OPTIONS

{

        //

        // Do not snap the baseline of the text vertically.

        //

        D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = 0x00000001,

        //

        // Clip the text to the content bounds.

        //

        D2D1_DRAW_TEXT_OPTIONS_CLIP = 0x00000002,

        D2D1_DRAW_TEXT_OPTIONS_NONE = 0x00000000,

        D2D1_DRAW_TEXT_OPTIONS_FORCE_DWORD = 0xffffffff

} D2D1_DRAW_TEXT_OPTIONS;

DEFINE_ENUM_FLAG_OPERATORS(D2D1_DRAW_TEXT_OPTIONS);

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_PIXEL_FORMAT

//

//------------------------------------------------------------------------------

typedef struct D2D1_PIXEL_FORMAT

{

    DXGI_FORMAT format;

    D2D1_ALPHA_MODE alphaMode;

} D2D1_PIXEL_FORMAT;

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;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_BITMAP_PROPERTIES

//

//------------------------------------------------------------------------------

typedef struct D2D1_BITMAP_PROPERTIES

{

    D2D1_PIXEL_FORMAT pixelFormat;

    FLOAT dpiX;

    FLOAT dpiY;

} D2D1_BITMAP_PROPERTIES;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_GRADIENT_STOP

//

//------------------------------------------------------------------------------

typedef struct D2D1_GRADIENT_STOP

{

    FLOAT position;

    D2D1_COLOR_F color;

} D2D1_GRADIENT_STOP;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_BRUSH_PROPERTIES

//

//------------------------------------------------------------------------------

typedef struct D2D1_BRUSH_PROPERTIES

{

    FLOAT opacity;

    D2D1_MATRIX_3X2_F transform;

} D2D1_BRUSH_PROPERTIES;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_BITMAP_BRUSH_PROPERTIES

//

//------------------------------------------------------------------------------

typedef struct D2D1_BITMAP_BRUSH_PROPERTIES

{

    D2D1_EXTEND_MODE extendModeX;

    D2D1_EXTEND_MODE extendModeY;

    D2D1_BITMAP_INTERPOLATION_MODE interpolationMode;

} D2D1_BITMAP_BRUSH_PROPERTIES;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES

//

//------------------------------------------------------------------------------

typedef struct D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES

{

    D2D1_POINT_2F startPoint;

    D2D1_POINT_2F endPoint;

} D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES

//

//------------------------------------------------------------------------------

typedef struct D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES

{

    D2D1_POINT_2F center;

    D2D1_POINT_2F gradientOriginOffset;

    FLOAT radiusX;

    FLOAT radiusY;

} D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_ARC_SIZE

//

//  Synopsis:

//      Differentiates which of the two possible arcs could match the given arc

//      parameters.

//

//------------------------------------------------------------------------------

typedef enum D2D1_ARC_SIZE

{

        D2D1_ARC_SIZE_SMALL = 0,

        D2D1_ARC_SIZE_LARGE = 1,

        D2D1_ARC_SIZE_FORCE_DWORD = 0xffffffff

} D2D1_ARC_SIZE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_CAP_STYLE

//

//  Synopsis:

//      Enum which descibes the drawing of the ends of a line.

//

//------------------------------------------------------------------------------

typedef enum D2D1_CAP_STYLE

{

        //

        // Flat line cap.

        //

        D2D1_CAP_STYLE_FLAT = 0,

        //

        // Square line cap.

        //

        D2D1_CAP_STYLE_SQUARE = 1,

        //

        // Round line cap.

        //

        D2D1_CAP_STYLE_ROUND = 2,

        //

        // Triangle line cap.

        //

        D2D1_CAP_STYLE_TRIANGLE = 3,

        D2D1_CAP_STYLE_FORCE_DWORD = 0xffffffff

} D2D1_CAP_STYLE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_DASH_STYLE

//

//------------------------------------------------------------------------------

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;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_LINE_JOIN

//

//  Synopsis:

//      Enum which descibes the drawing of the corners on the line.

//

//------------------------------------------------------------------------------

typedef enum D2D1_LINE_JOIN

{

        //

        // Miter join.

        //

        D2D1_LINE_JOIN_MITER = 0,

        //

        // Bevel join.

        //

        D2D1_LINE_JOIN_BEVEL = 1,

        //

        // Round join.

        //

        D2D1_LINE_JOIN_ROUND = 2,

        //

        // Miter/Bevel join.

        //

        D2D1_LINE_JOIN_MITER_OR_BEVEL = 3,

        D2D1_LINE_JOIN_FORCE_DWORD = 0xffffffff

} D2D1_LINE_JOIN;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_COMBINE_MODE

//

//  Synopsis:

//      This enumeration describes the type of combine operation to be performed.

//

//------------------------------------------------------------------------------

typedef enum D2D1_COMBINE_MODE

{

        //

        // Produce a geometry representing the set of points contained in either

        // the first or the second geometry.

        //

        D2D1_COMBINE_MODE_UNION = 0,

        //

        // Produce a geometry representing the set of points common to the first

        // and the second geometries.

        //

        D2D1_COMBINE_MODE_INTERSECT = 1,

        //

        // Produce a geometry representing the set of points contained in the

        // first geometry or the second geometry, but not both.

        //

        D2D1_COMBINE_MODE_XOR = 2,

        //

        // Produce a geometry representing the set of points contained in the

        // first geometry but not the second geometry.

        //

        D2D1_COMBINE_MODE_EXCLUDE = 3,

        D2D1_COMBINE_MODE_FORCE_DWORD = 0xffffffff

} D2D1_COMBINE_MODE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_GEOMETRY_RELATION

//

//------------------------------------------------------------------------------

typedef enum D2D1_GEOMETRY_RELATION

{

        //

        // The relation between the geometries couldn't be determined. This value is never

        // returned by any D2D method.

        //

        D2D1_GEOMETRY_RELATION_UNKNOWN = 0,

        //

        // The two geometries do not intersect at all.

        //

        D2D1_GEOMETRY_RELATION_DISJOINT = 1,

        //

        // The passed in geometry is entirely contained by the object.

        //

        D2D1_GEOMETRY_RELATION_IS_CONTAINED = 2,

        //

        // The object entirely contains the passed in geometry.

        //

        D2D1_GEOMETRY_RELATION_CONTAINS = 3,

        //

        // The two geometries overlap but neither completely contains the other.

        //

        D2D1_GEOMETRY_RELATION_OVERLAP = 4,

        D2D1_GEOMETRY_RELATION_FORCE_DWORD = 0xffffffff

} D2D1_GEOMETRY_RELATION;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_GEOMETRY_SIMPLIFICATION_OPTION

//

//  Synopsis:

//      Specifies how simple the output of a simplified geometry sink should be.

//

//------------------------------------------------------------------------------

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;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_FIGURE_BEGIN

//

//  Synopsis:

//      Indicates whether the given figure is filled or hollow.

//

//------------------------------------------------------------------------------

typedef enum D2D1_FIGURE_BEGIN

{

        D2D1_FIGURE_BEGIN_FILLED = 0,

        D2D1_FIGURE_BEGIN_HOLLOW = 1,

        D2D1_FIGURE_BEGIN_FORCE_DWORD = 0xffffffff

} D2D1_FIGURE_BEGIN;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_FIGURE_END

//

//  Synopsis:

//      Indicates whether the figure ir open or closed on its end point.

//

//------------------------------------------------------------------------------

typedef enum D2D1_FIGURE_END

{

        D2D1_FIGURE_END_OPEN = 0,

        D2D1_FIGURE_END_CLOSED = 1,

        D2D1_FIGURE_END_FORCE_DWORD = 0xffffffff

} D2D1_FIGURE_END;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_BEZIER_SEGMENT

//

//  Synopsis:

//      Describes a cubic bezier in a path.

//

//------------------------------------------------------------------------------

typedef struct D2D1_BEZIER_SEGMENT

{

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

    D2D1_POINT_2F point3;

} D2D1_BEZIER_SEGMENT;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_TRIANGLE

//

//  Synopsis:

//      Describes a triangle.

//

//------------------------------------------------------------------------------

typedef struct D2D1_TRIANGLE

{

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

    D2D1_POINT_2F point3;

} D2D1_TRIANGLE;

//+-----------------------------------------------------------------------------

//

//  Flag:

//      D2D1_PATH_SEGMENT

//

//  Synopsis:

//      Indicates whether the given segment should be stroked, or, if the join between

//      this segment and the previous one should be smooth.

//

//------------------------------------------------------------------------------

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;

DEFINE_ENUM_FLAG_OPERATORS(D2D1_PATH_SEGMENT);

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_SWEEP_DIRECTION

//

//------------------------------------------------------------------------------

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;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_FILL_MODE

//

//------------------------------------------------------------------------------

typedef enum D2D1_FILL_MODE

{

        D2D1_FILL_MODE_ALTERNATE = 0,

        D2D1_FILL_MODE_WINDING = 1,

        D2D1_FILL_MODE_FORCE_DWORD = 0xffffffff

} D2D1_FILL_MODE;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_ARC_SEGMENT

//

//  Synopsis:

//      Describes an arc that is defined as part of a path.

//

//------------------------------------------------------------------------------

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;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_QUADRATIC_BEZIER_SEGMENT

//

//------------------------------------------------------------------------------

typedef struct D2D1_QUADRATIC_BEZIER_SEGMENT

{

    D2D1_POINT_2F point1;

    D2D1_POINT_2F point2;

} D2D1_QUADRATIC_BEZIER_SEGMENT;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_ELLIPSE

//

//------------------------------------------------------------------------------

typedef struct D2D1_ELLIPSE

{

    D2D1_POINT_2F point;

    FLOAT radiusX;

    FLOAT radiusY;

} D2D1_ELLIPSE;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_ROUNDED_RECT

//

//------------------------------------------------------------------------------

typedef struct D2D1_ROUNDED_RECT

{

    D2D1_RECT_F rect;

    FLOAT radiusX;

    FLOAT radiusY;

} D2D1_ROUNDED_RECT;

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_STROKE_STYLE_PROPERTIES

//

//  Synopsis:

//      Properties, aside from the width, that allow geometric penning to be specified.

//

//------------------------------------------------------------------------------

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;

//+-----------------------------------------------------------------------------

//

//  Flag:

//      D2D1_LAYER_OPTIONS

//

//  Synopsis:

//      Specified options that can be applied when a layer resource is applied to create

//      a layer.

//

//------------------------------------------------------------------------------

typedef enum D2D1_LAYER_OPTIONS

{

        D2D1_LAYER_OPTIONS_NONE = 0x00000000,

        //

        // 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.

        //

        D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = 0x00000001,

        D2D1_LAYER_OPTIONS_FORCE_DWORD = 0xffffffff

} D2D1_LAYER_OPTIONS;

DEFINE_ENUM_FLAG_OPERATORS(D2D1_LAYER_OPTIONS);

//+-----------------------------------------------------------------------------

//

//  Struct:

//      D2D1_LAYER_PARAMETERS

//

//------------------------------------------------------------------------------

typedef struct D2D1_LAYER_PARAMETERS

{

    //

    // 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.

    //

    D2D1_RECT_F contentBounds;

    //

    // A general mask that can be optionally applied to the content. Content not inside

    // the fill of the mask will not be rendered.

    //

    __field_ecount_opt(1) ID2D1Geometry *geometricMask;

    //

    // Specifies whether the mask should be aliased or antialiased.

    //

    D2D1_ANTIALIAS_MODE maskAntialiasMode;

    //

    // An additional transform that may be applied to the mask in addition to the

    // current world transform.

    //

    D2D1_MATRIX_3X2_F maskTransform;

    //

    // The opacity with which all of the content in the layer will be blended back to

    // the target when the layer is popped.

    //

    FLOAT opacity;

    //

    // 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.

    //

    __field_ecount_opt(1) ID2D1Brush *opacityBrush;

    //

    // Specifies if ClearType will be rendered into the layer.

    //

    D2D1_LAYER_OPTIONS layerOptions;

} D2D1_LAYER_PARAMETERS;

//+-----------------------------------------------------------------------------

//

//  Flag:

//      D2D1_WINDOW_STATE

//

//------------------------------------------------------------------------------

typedef enum D2D1_WINDOW_STATE

{

        D2D1_WINDOW_STATE_NONE = 0x0000000,

        D2D1_WINDOW_STATE_OCCLUDED = 0x0000001,

        D2D1_WINDOW_STATE_FORCE_DWORD = 0xffffffff

} D2D1_WINDOW_STATE;

DEFINE_ENUM_FLAG_OPERATORS(D2D1_WINDOW_STATE);

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_RENDER_TARGET_TYPE

//

//------------------------------------------------------------------------------

typedef enum D2D1_RENDER_TARGET_TYPE

{

        //

        // D2D is free to choose the render target type for the caller.

        //

        D2D1_RENDER_TARGET_TYPE_DEFAULT = 0,

        //

        // The render target will render using the CPU.

        //

        D2D1_RENDER_TARGET_TYPE_SOFTWARE = 1,

        //

        // The render target will render using the GPU.

        //

        D2D1_RENDER_TARGET_TYPE_HARDWARE = 2,

        D2D1_RENDER_TARGET_TYPE_FORCE_DWORD = 0xffffffff

} D2D1_RENDER_TARGET_TYPE;

//+-----------------------------------------------------------------------------

//

//  Enum:

//      D2D1_FEATURE_LEVEL

//

//------------------------------------------------------------------------------

typedef enum D2D1_FEATURE_LEVEL

{

        //

        // The caller does not require a particular underlying D3D device level.