diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs index 5498807..294c2fb 100644 --- a/src/Generator/Program.cs +++ b/src/Generator/Program.cs @@ -24,7 +24,7 @@ public static class Program "Graphics.Direct3D.Dxc.json", "Graphics.Direct2D.Common.json", "Graphics.Imaging.json", - //"Graphics.DirectWrite.json", + "Graphics.DirectWrite.json", //"Graphics.Direct2D.json", //"Graphics.Imaging.D2D.json", @@ -85,6 +85,9 @@ public static class Program { "Graphics.Gdi.HBITMAP", "IntPtr" }, { "Graphics.Gdi.HPALETTE", "IntPtr" }, { "UI.WindowsAndMessaging.HICON", "IntPtr" }, + { "Globalization.FONTSIGNATURE", "Win32.Graphics.Gdi.FontSignature" }, + { "Graphics.Gdi.LOGFONTA", "Win32.Graphics.Gdi.LogFontA" }, + { "Graphics.Gdi.LOGFONTW", "Win32.Graphics.Gdi.LogFontW" }, { "Graphics.Direct3D.D3DVECTOR", "Vector3" }, { "Graphics.Direct3D.D3DMATRIX", "Matrix4x4" }, @@ -893,7 +896,7 @@ public static class Program } // Generate docs - //DocGenerator.Generate(new[] { "WIC" }, Path.Combine(outputPath, "Imaging.xml")); + //DocGenerator.Generate(new[] { "D2D1" }, Path.Combine(outputPath, "Direct2D.xml")); //DocGenerator.Generate(new[] { "DWRITE" }, Path.Combine(outputPath, "DirectWrite.xml")); //DocGenerator.Generate(new[] { "D3D" }, Path.Combine(outputPath, "Direct3D.xml")); //DocGenerator.Generate(new[] { "DXGI" }, Path.Combine(outputPath, "Dxgi.xml")); diff --git a/src/Vortice.Win32/Com/VariantFullType.cs b/src/Vortice.Win32/Com/VariantFullType.cs index 171e461..e6a4e5b 100644 --- a/src/Vortice.Win32/Com/VariantFullType.cs +++ b/src/Vortice.Win32/Com/VariantFullType.cs @@ -31,7 +31,7 @@ public readonly struct VariantFullType : IEquatable } public bool Equals(VariantFullType other) => vt == other.vt; - public override bool Equals(object obj) => obj is VariantFullType other && Equals(other); + public override bool Equals(object? obj) => obj is VariantFullType other && Equals(other); public override int GetHashCode() => vt.GetHashCode(); public static bool operator ==(VariantFullType left, VariantFullType right) => left.Equals(right); public static bool operator !=(VariantFullType left, VariantFullType right) => !left.Equals(right); diff --git a/src/Vortice.Win32/ComPtr.cs b/src/Vortice.Win32/ComPtr.cs index fe72bd6..5080e08 100644 --- a/src/Vortice.Win32/ComPtr.cs +++ b/src/Vortice.Win32/ComPtr.cs @@ -232,7 +232,9 @@ public unsafe struct ComPtr : IDisposable return ptr_; } - /// Gets the address of the current instance as a raw double pointer. This method is only valid when the current instance is on the stack or pinned. + /// + /// Gets the address of the current instance as a raw double pointer. + /// This method is only valid when the current instance is on the stack or pinned. /// /// The raw pointer to the current instance. [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -252,6 +254,17 @@ public unsafe struct ComPtr : IDisposable return (void**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); } + /// + /// Gets the address of the current instance as a raw double pointer. + /// This method is only valid when the current instance is on the stack or pinned. + /// + /// The raw pointer to the current instance. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public readonly IUnknown** GetIUnknownAddressOf() + { + return (IUnknown**)Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + } + /// Gets the address of the current instance as a raw double pointer. /// The raw pointer to the current instance. [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/Vortice.Win32/Generated/Direct2D.xml b/src/Vortice.Win32/Generated/Direct2D.xml new file mode 100644 index 0000000..ac3f8d3 --- /dev/null +++ b/src/Vortice.Win32/Generated/Direct2D.xml @@ -0,0 +1,9514 @@ + + + + + Identifiers for properties of the Composite effect. + Microsoft Docs: + + + + The mode used for the effect. + + +Type is D2D1_COMPOSITE_MODE. + +Default value is D2D1_COMPOSITE_MODE_SOURCE_OVER + + + + Specifies how the alpha value of a bitmap or render target should be treated. + Microsoft Docs: + + + + The alpha value might not be meaningful. + + + The alpha value has been premultiplied. Each color is first scaled by the alpha value. The alpha value itself is the same in both straight and premultiplied alpha. Typically, no color channel value is greater than the alpha channel value. If a color channel value in a premultiplied format is greater than the alpha channel, the standard source-over blending math results in an additive blend. + + + The alpha value has not been premultiplied. The alpha channel indicates the transparency of the color. + + + The alpha value is ignored. + + + + Flush all device contexts that reference a given bitmap. + Microsoft Docs: + The bitmap, created on this device, for which all referencing device contexts will be flushed. + + + + + Draws an image to the device context using the specified blend mode. Results are equivalent to using Direct2D's built-in Blend effect. + Microsoft Docs: + The image to be drawn to the device context. + The blend mode to be used. See Blend modes for more info. + The offset in the destination space that the image will be rendered to. + The entire logical extent of the image will be rendered to the corresponding destination. + If not specified, the destination origin will be (0, 0). The top-left corner of the image will be mapped to the target offset. + This will not necessarily be the origin. The default value is NULL. + The corresponding rectangle in the image space will be mapped to the given origins when processing the image. The default value is NULL. + The interpolation mode that will be used to scale the image if necessary. The default value is D2D1_INTERPOLATION_MODE_LINEAR. + + + + + Creates a new ID2D1DeviceContext4 from this Direct2D device. + Microsoft Docs: + The options to be applied to the created device context. + When this method returns, contains a pointer to the new device context. + + + + + Updates the commands array. Existing commands not updated by this method are preserved. The array is resized larger if necessary to accomodate the new commands. + Microsoft Docs: + The commands array. + The number of commands to update. + The index at which to begin updating commands. Must be less than or equal to the size of the commands array. + + + + + Defines how the world transform, dots per inch (dpi), and stroke width affect the shape of the pen used to stroke a primitive. + Microsoft Docs: + + + + The stroke respects the currently set world transform, the dpi, and the stroke width. + + + The stroke does not respect the world transform but it does respect the dpi and stroke width. + + + The stroke is forced to 1 pixel wide (in device space) and does not respect the world transform, the dpi, or the stroke width. + + + + Identifiers for properties of the Exposure effect. + Microsoft Docs: + + + + The D2D1_EXPOSURE_PROP_EXPOSURE_VALUE property is a float value that specifies how much to increase or decrease the exposure of the image. The allowed range is -2.0 to 2.0. The default value is 0.0 (no change). + + + + Sets the render information for the transform. + Microsoft Docs: + The interface supplied to the transform to allow specifying the CPU based transform pass. + + + + + Defines a transform that uses a compute shader. + Microsoft Docs: + + + + + Gets the parent element. + Microsoft Docs: + Outputs the parent element. + + + + + The meetOrSlice portion of the SVG preserveAspectRatio attribute. + Microsoft Docs: + + + + Scale the viewBox up as much as possible such that the entire viewBox is visible within the viewport. + + + Scale the viewBox down as much as possible such that the entire viewport is + covered by the viewBox. + + + + Indicates whether the vertex buffer changes infrequently or frequently. + Microsoft Docs: + + + + The created vertex buffer is updated infrequently. + + + The created vertex buffer is changed frequently. + + + + A description of a single element to the vertex layout. + Microsoft Docs: + + + + The HLSL semantic associated with this element in a shader input-signature. + + + The semantic index for the element. A semantic index modifies a semantic, with an integer index number. A semantic index is only needed in a case where there is more than one element with the same semantic. For example, a 4x4 matrix would have four components each with the semantic name matrix; however, each of the four components would have different semantic indices (0, 1, 2, and 3). + + + The data type of the element data. + + + An integer value that identifies the input-assembler. Valid values are between 0 and 15. + + + The offset in bytes between each element. + + + + Creates an SVG glyph style object. + Microsoft Docs: + On completion points to the created ID2D1SvgGlyphStyle object. + + + + + Fills an opacity mask on the command sink. + Microsoft Docs: + The bitmap whose alpha channel will be sampled to define the opacity mask. + The brush with which to fill the mask. + The destination rectangle in which to fill the mask. If not specified, this is the origin. + The source rectangle within the opacity mask. If not specified, this is the entire mask. + + + + + Gets the length of the text content value. + Microsoft Docs: + + + + + Adds the provided node to the transform graph. + Microsoft Docs: + The node that will be added to the transform graph. + + + + + Indicates the gamma space in which the gradient stops are interpolated. + Microsoft Docs: + + + + + Represents the bit depth of the imaging pipeline in Direct2D. + Microsoft Docs: + + + + The buffer precision is not specified. + + + Use 8-bit normalized integer per channel. + + + Use 8-bit normalized integer standard RGB data per channel. + + + Use 16-bit normalized integer per channel. + + + Use 16-bit floats per channel. + + + Use 32-bit floats per channel. + + + Forces this enumeration to compile to 32 bits in size. Without this value, some compilers would allow this enumeration to compile to a size other than 32 bits. + +Do not use this value. + + + + Gets commands from the commands array. + Microsoft Docs: + Buffer to contain the commands. + The element count of the buffer. + The index of the first commands to retrieve. + + + + + The rendering priority affects the extent to which Direct2D will throttle its rendering workload. + Microsoft Docs: + + + + No change in rendering workload priority. + + + The device and its associated device contexts are given a lower priority than others. + + + + Defines a mappable single-dimensional vertex buffer. + Microsoft Docs: + + + + + Specifies the appearance of the ink nib (pen tip) as part of an D2D1_INK_STYLE_PROPERTIES structure. + Microsoft Docs: + + + + The pen tip is circular. + + + The pen tip is square. + + + + Specifies how units in Direct2D will be interpreted. + Microsoft Docs: + + + + Units will be interpreted as device-independent pixels (1/96"). + + + Units will be interpreted as pixels. + + + + Extends the input rectangle to infinity using the specified extend modes. + Microsoft Docs: + + + + + Indicates how pixel shader sampling will be restricted. + Microsoft Docs: + + + + The pixel shader is not restricted in its sampling. + + + The pixel shader samples inputs only at the same scene coordinate as the output pixel and returns transparent black whenever the input pixels are also transparent black. + + + + Specifies the types of properties supported by the Direct2D property interface. + Microsoft Docs: + + + + An unknown property. + + + An arbitrary-length string. + + + A 32-bit integer value constrained to be either 0 or 1. + + + An unsigned 32-bit integer. + + + A signed 32-bit integer. + + + A 32-bit float. + + + Two 32-bit float values. + + + Three 32-bit float values. + + + Four 32-bit float values. + + + An arbitrary number of bytes. + + + A returned COM or nano-COM interface. + + + An enumeration. The value should be treated as a UINT32 with a defined array of fields to specify the bindings to human-readable strings. + + + An enumeration. The value is the count of sub-properties in the array. The set of array elements will be contained in the sub-property. + + + A CLSID. + + + A 3x2 matrix of float values. + + + A 4x2 matrix of float values. + + + A 4x4 matrix of float values. + + + A 5x4 matrix of float values. + + + A nano-COM color context interface pointer. + + + + Draws the formatted text described by the specified IDWriteTextLayout object. + Microsoft Docs: + The point, described in device-independent pixels, at which the upper-left corner of the text described by textLayout is drawn. + The formatted text to draw. Any drawing effects that do not inherit from ID2D1Resource are ignored. If there are drawing effects that inherit from ID2D1Resource that are not brushes, this method fails and the render target is put in an error state. + The brush used to paint any text in textLayout that does not already have a brush associated with it as a drawing effect (specified by the IDWriteTextLayout::SetDrawingEffect method). + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. The default value is D2D1_DRAW_TEXT_OPTIONS_NONE, which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + + + + + Removes the attribute from this element. + Microsoft Docs: + The name of the attribute to remove. + + + + + Specifies the flip and rotation at which an image appears. + Microsoft Docs: + + + + The orientation is unchanged. + + + The image is flipped horizontally. + + + The image is rotated clockwise 180 degrees. + + + The image is rotated clockwise 180 degrees, then flipped horizontally. + + + The image is rotated clockwise 90 degrees, then flipped horizontally. + + + The image is rotated clockwise 270 degrees. + + + The image is rotated clockwise 270 degrees, then flipped horizontally. + + + The image is rotated clockwise 90 degrees. + + + + Describes the render information common to all of the various transform implementations. + Microsoft Docs: + + + + + Renders to an intermediate texture created by the CreateCompatibleRenderTarget method. + Microsoft Docs: + + + + + Identifiers for the properties of the Color management effect. + Microsoft Docs: + + + + The source color space information. + + +The type is ID2D1ColorContext. + +The default value is NULL. + + + Which ICC rendering intent to use. + + +The type is D2D1_COLORMANAGEMENT_RENDERING_INTENT. + +The default value is D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL. + + + The destination color space information. + + +The type is ID2D1ColorContext. + +The default value is NULL. + + + Which ICC rendering intent to use. + + +The type is D2D1_COLORMANAGEMENT_RENDERING_INTENT. + +The default value is D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL. + + + How to interpret alpha data that is contained in the input image. + + +The type is D2D1_COLORMANAGEMENT_ALPHA_MODE. + +The default value is D2D1_COLORMANAGEMENT_ALPHA_MODE_PREMULTIPLIED. + + + The quality level of the transform. + + +The type is D2D1_COLORMANAGEMENT_QUALITY. + +The default value is D2D1_COLORMANAGEMENT_QUALITY_NORMAL. + + + + Describes the shape at the end of a line or segment. + Microsoft Docs: + + + + A cap that does not extend past the last point of the line. Comparable to cap used for objects other than lines. + + + Half of a square that has a length equal to the line thickness. + + + A semicircle that has a diameter equal to the line thickness. + + + An isosceles right triangle whose hypotenuse is equal in length to the thickness of the line. + + + + Gets the current antialiasing mode for text and glyph drawing operations. + Microsoft Docs: + + + + + Changes the primitive blend mode that is used for all rendering operations in the device context. + Microsoft Docs: + The primitive blend to use. + + + + + Creates a color context from a color space. + Microsoft Docs: + The space of color context to create. + A buffer containing the ICC profile bytes used to initialize the color context when space is D2D1_COLOR_SPACE_CUSTOM. For other types, the parameter is ignored and should be set to NULL. + The size in bytes of Profile. + When this method returns, contains the address of a pointer to a new color context object. + + + + + Gets the mode that is being used to interpret values by the device context. + Microsoft Docs: + + + + + Creates Direct2D resources. + Microsoft Docs: + + + + + Serializes an element and its subtree to XML. The output XML is encoded as UTF-8. + Microsoft Docs: + An output stream to contain the SVG XML subtree. + The root of the subtree. If null, the entire document is serialized. + + + + + Retrieves the properties specified when the transformed image source was created. + Microsoft Docs: + the properties specified when the transformed image source was created. + + + + + Connects two nodes inside the transform graph. + Microsoft Docs: + The node from which the connection will be made. + The node to which the connection will be made. + The node input that will be connected. + + + + + Returns the element on which this attribute is set. Returns null if the attribute is not set on any element. + Microsoft Docs: + When this method completes, this will contain a pointer to the element on which this attribute is set. + + + + + Gets data from the segment data array. + Microsoft Docs: + Buffer to contain the segment data array. + The element count of the buffer. + The index of the first segment data to retrieve. + + + + + Represents a single group of sprites with their associated drawing properties. + Microsoft Docs: + + + + + Allows a caller to control the channel depth of a stage in the rendering pipeline. + Microsoft Docs: + + + + The channel depth is the default. It is inherited from the inputs. + + + The channel depth is 1. + + + The channel depth is 4. + + + + Gets the next sibling of the referenceChild element. + Microsoft Docs: + The referenceChild must be an immediate child of this element. + The output nextChild element will be non-null if the referenceChild has a next sibling. If the referenceChild is the last child, the output is null. + + + + + Performs the inverse mapping to MapOutputRectToInputRects. + Microsoft Docs: + An array of input rectangles to be mapped to the output rectangle. The inputRects parameter is always equal to the input bounds. + An array of input rectangles to be mapped to the opaque output rectangle. + The number of inputs specified. The implementation guarantees that this is equal to the number of inputs specified on the transform. + The output rectangle that maps to the corresponding input rectangle. + The output rectangle that maps to the corresponding opaque input rectangle. + + + + + Retrieves the device context associated with this render target. + Microsoft Docs: + A value that specifies whether the device context should be cleared. + When this method returns, contains the device context associated with this render target. You must allocate storage for this parameter. + + + + + Inserts newChild as a child of this element, before the referenceChild element. + Microsoft Docs: + The element to be inserted. + The element that the child should be inserted before. + If referenceChild is null, the newChild is placed as the last child. + If referenceChild is non-null, it must be an immediate child of this element. + + + + + Sets the element id which acts as the paint server. This id is used if the paint type is D2D1_SVG_PAINT_TYPE_URI. + Microsoft Docs: + The element id which acts as the paint server. This id is used if the paint type is D2D1_SVG_PAINT_TYPE_URI. + + + + + Retrieves the starting coordinates of the linear gradient. + Microsoft Docs: + + + + + The interpolation mode the 3D transform effect uses on the image. There are 5 scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + + Leaves the Direct2D API critical section, if it exists. + Microsoft Docs: + + + + + The ID2D1PathGeometry1 interface adds functionality to ID2D1PathGeometry. In particular, it provides the path geometry-specific ComputePointAndSegmentAtLength method. + Microsoft Docs: + + + + + Identifiers for properties of the YCbCr effect. + Microsoft Docs: + + + + Specifies the chroma subsampling of the input chroma image. + + +The type is D2D1_YCBCR_CHROMA_SUBSAMPLING. + +The default value is D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO. + + + A 3x2 Matrix specifying the axis-aligned affine transform of the image. Axis aligned transforms include Scale, Flips, and 90 degree rotations. + + +The type is D2D1_MATRIX_3X2_F. + +The default value is Matrix3x2F::Identity(). + + + The interpolation mode. + + +The type is D2D1_YCBCR_INTERPOLATION_MODE. + + + + Gets the blend description of the corresponding blend transform object. + Microsoft Docs: + When this method returns, contains the blend description specified for the blend transform. + + + + + Gets the color space after interpolation has occurred. + Microsoft Docs: + + + + + 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. + Microsoft Docs: + + + + + Gets the rectangle that will be used as the bounds of the image when drawn as an image brush. + Microsoft Docs: + When this method returns, contains the address of the output source rectangle. + + + + + Registers an effect within the factory instance with the property XML specified as a stream. + Microsoft Docs: + The identifier of the effect to be registered. + A list of the effect properties, types, and metadata. + An array of properties and methods. + +This binds a property by name to a particular method implemented by the effect author to handle the property. + The name must be found in the corresponding propertyXml. + The number of bindings in the binding array. + The static factory that is used to create the corresponding effect. + + + + + Sets a single transform node as being equivalent to the whole graph. + Microsoft Docs: + The node to be set. + + + + + Identifiers for properties of the Flood effect. + Microsoft Docs: + + + + The color and opacity of the bitmap. This property is a D2D1_VECTOR_4F. The individual values for each channel are of type FLOAT, unbounded and unitless. + The effect doesn't modify the values for the channels. + + +The RGBA values for each channel range from 0 to 1. + +The type is D2D1_VECTOR_4F. + +The default value is {0.0f, 0.0f, 0.0f, 1.0f}. + + + + Uses the specified input as the effect output. + Microsoft Docs: + The index of the input to the effect. + + + + + Gets the number of top-level properties. + Microsoft Docs: + + + + + Return the render target's dots per inch (DPI). + Microsoft Docs: + When this method returns, contains the horizontal DPI of the render target. This parameter is passed uninitialized. + When this method returns, contains the vertical DPI of the render target. This parameter is passed uninitialized. + + + + + Interface describing an SVG stroke-dasharray value. + Microsoft Docs: + + + + + Pushes a layer onto the clip and layer stack. + Microsoft Docs: + The parameters that define the layer. + The layer resource that receives subsequent drawing operations. + + + + + Unregisters an effect within the factory instance that corresponds to the classId provided. + Microsoft Docs: + The identifier of the effect to be unregistered. + + + + + Determines what gamma is used for interpolation and blending. + Microsoft Docs: + + + + Colors are manipulated in 2.2 gamma color space. + + + Colors are manipulated in 1.0 gamma color space. + + + Colors are manipulated in ST.2084 PQ gamma color space. + + + + This sets the output bounds for the support transform. + Microsoft Docs: + The output bounds. + + + + + Retrieves the type of shape used at the beginning of a stroke. + Microsoft Docs: + + + + + A locking mechanism from a Direct2D factory that Direct2D uses to control exclusive resource access in an app that is uses multiple threads. + Microsoft Docs: + + + + + Gets the number of invalid output rectangles that have accumulated on the effect. + Microsoft Docs: + The effect to count the invalid rectangles on. + The returned rectangle count. + + + + + Creates a render target that draws to a Windows Graphics Device Interface (GDI) device context. + Microsoft Docs: + The rendering mode, pixel format, remoting options, DPI information, and the minimum DirectX support required for hardware rendering. To enable the device context (DC) render target to work with GDI, set the DXGI format to DXGI_FORMAT_B8G8R8A8_UNORM and the alpha mode to D2D1_ALPHA_MODE_PREMULTIPLIED or D2D1_ALPHA_MODE_IGNORE. For more information about pixel formats, see Supported Pixel Formats and Alpha Modes. + When this method returns, dcRenderTarget contains the address of the pointer to the ID2D1DCRenderTarget created by the method. + + + + + Removes dashes from the end of the array. + Microsoft Docs: + Specifies how many dashes to remove. + + + + + Specifies which way a color profile is defined. + Microsoft Docs: + + + + + Draws a line between the specified points using the specified stroke style. + Microsoft Docs: + The start point of the line, in device-independent pixels. + The end point of the line, in device-independent pixels. + The brush used to paint the line's stroke. + The width of the stroke, in device-independent pixels. The value must be greater than or equal to 0.0f. If this parameter isn't specified, it defaults to 1.0f. The stroke is centered on the line. + The style of stroke to paint, or NULL to paint a solid line. + + + + + Sets the maximum amount of texture memory Direct2D accumulates before it purges the image caches and cached texture allocations. + Microsoft Docs: + + + + + Retrieves the geometries in the geometry group. + Microsoft Docs: + When this method returns, contains the address of a pointer to an array of geometries to be filled by this method. The length of the array is specified by the geometryCount parameter. If the array is NULL, then this method performs no operation. You must allocate the memory for this array. + A value indicating the number of geometries to return in the geometries array. If this value is less than the number of geometries in the geometry group, the remaining geometries are omitted. If this value is larger than the number of geometries in the geometry group, the extra geometries are set to NULL. To obtain the number of geometries currently in the geometry group, use the GetSourceGeometryCount method. + + + + + Specifies the text-rendering configuration of the drawing state. + Microsoft Docs: + The text-rendering configuration of the drawing state, or NULL to use default settings. + + + + + Computes the maximum factor by which a given transform can stretch any vector. + Microsoft Docs: + The input transform matrix. + + + + + Gets the extend mode of the image brush on the x-axis. + Microsoft Docs: + + + + + A support transform for effects to modify the output rectangle of the previous effect or bitmap. + Microsoft Docs: + + + + + Creates a points object which can be used to set a points attribute on a polygon or polyline element. + Microsoft Docs: + The points in the point collection. + The number of points in the points argument. + The created ID2D1SvgPointCollection object. + + + + + Identifiers for properties of the Straighten effect. + Microsoft Docs: + + + + The D2D1_STRAIGHTEN_PROP_ANGLE property is a float value that specifies how much the image should be rotated. The allowed range is -45.0 to 45.0. The default value is 0.0. + + + The D2D1_STRAIGHTEN_PROP_MAINTAIN_SIZE property is a boolean value that specifies whether the image will be scaled such that the original size is maintained without any invalid regions. + The default value is True. + + + The D2D1_STRAIGHTEN_PROP_SCALE_MODE property is a D2D1_STRAIGHTEN_SCALE_MODE enumeration value indicating the scaling mode that should be used. + + + + Creates a ID2D1Device object. + Microsoft Docs: + The IDXGIDevice object used when creating the ID2D1Device. + The requested ID2D1Device object. + + + + + Describes the options that transforms may set on input textures. + Microsoft Docs: + + + + The type of filter to apply to the input texture. + + + The mip level to retrieve from the upstream transform, if specified. + + + + Creates an ID2D1Device2 object. + Microsoft Docs: + The IDXGIDevice object used when creating the ID2D1Device2. + The requested ID2D1Device2 object. + + + + + Represents a brush based on an ID2D1Image. + Microsoft Docs: + + + + + Simple description of a color space. + Microsoft Docs: + + + + The XY coordinates of the red primary in CIEXYZ space. + + + The XY coordinates of the green primary in CIEXYZ space. + + + The XY coordinates of the blue primary in CIEXYZ space. + + + The X/Z tristimulus values for the whitepoint, normalized for relative luminance. + + + The gamma encoding to use for this color space. + + + + Provides access to metafile records, including their type, data, and flags. + Microsoft Docs: + The type of metafile record being processed. Please see MS-EMF and MS-EMFPLUS for a list of record types. + The data contained in this record. Please see MS-EMF and MS-EMFPLUS for information on record data layouts. + TThe size of the data pointed to by recordData. + The set of flags set for this record. Please see MS-EMF and MS-EMFPLUS for information on record flags. + + + + + Retrieves the number of entries in the dashes array. + Microsoft Docs: + + + + + Gets the precision of the gradient buffer. + Microsoft Docs: + + + + + Defines capabilities of the underlying Direct3D device which may be queried using ID2D1EffectContext::CheckFeatureSupport. + Microsoft Docs: + + + + A D2D1_FEATURE_DATA_DOUBLES structure should be filled. + + + A D2D1_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS structure should be filled. + + + + Defines a vertex shader and the input element description to define the input layout. + Microsoft Docs: + + + + A pointer to the buffer. + + + The size of the buffer. + + + An array of input assembler stage data types. + + + The number of input elements in the vertex shader. + + + The vertex stride. + + + + Contains rendering options (hardware or software), pixel format, DPI information, remoting options, and Direct3D support requirements for a render target. + Microsoft Docs: + + + + A value that specifies whether the render target should force hardware or software rendering. A value of D2D1_RENDER_TARGET_TYPE_DEFAULT specifies that the render target should use hardware rendering if it is available; otherwise, it uses software rendering. Note that WIC bitmap render targets do not support hardware rendering. + + + The pixel format and alpha mode of the render target. You can use the D2D1::PixelFormat function to create a pixel format that specifies that Direct2D should select the pixel format and alpha mode for you. For a list of pixel formats and alpha modes supported by each render target, see Supported Pixel Formats and Alpha Modes. + + + The horizontal DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + + + The vertical DPI of the render target. To use the default DPI, set dpiX and dpiY to 0. For more information, see the Remarks section. + + + A value that specifies how the render target is remoted and whether it should be GDI-compatible. Set to D2D1_RENDER_TARGET_USAGE_NONE to create a render target that is not compatible with GDI and uses Direct3D command-stream remoting if it is available. + + + A value that specifies the minimum Direct3D feature level required for hardware rendering. If the specified minimum level is not available, the render target uses software rendering if the type member is set to D2D1_RENDER_TARGET_TYPE_DEFAULT; if type is set to to D2D1_RENDER_TARGET_TYPE_HARDWARE, render target creation fails. A value of D2D1_FEATURE_LEVEL_DEFAULT indicates that Direct2D should determine whether the Direct3D feature level of the device is adequate. This field is used only when creating ID2D1HwndRenderTarget and ID2D1DCRenderTarget objects. + + + + Creates an ID2D1Device4 object. + Microsoft Docs: + The IDXGIDevice object used when creating the ID2D1Device4. + The requested ID2D1Device4 object. + + + + + Retrieves the number of gradient stops in the collection. + Microsoft Docs: + + + + + Specifies whether Direct2D provides synchronization for an ID2D1Factory and the resources it creates, so that they may be safely accessed from multiple threads. + Microsoft Docs: + + + + No synchronization is provided for accessing or writing to the factory or the objects it creates. If the factory or the objects are called from multiple threads, it is up to the application to provide access locking. + + + Direct2D provides synchronization for accessing and writing to the factory and the objects it creates, enabling safe access from multiple threads. + + + + Gets the DPI reported by the metafile. + Microsoft Docs: + Receives the horizontal DPI reported by the metafile. + Receives the vertical DPI reported by the metafile. + + + + + Indicates to the command sink a geometry to be filled. + Microsoft Docs: + The geometry that should be filled. + The primary brush used to fill the geometry. + A brush whose alpha channel is used to modify the opacity of the primary fill brush. + + + + + Gets the SVG element with the specified ID. + Microsoft Docs: + ID of the element to retrieve. + The element matching the specified ID. If the element cannot be found, the returned element will be null. + + + + + Specifies text rendering options to be applied to all subsequent text and glyph drawing operations. + Microsoft Docs: + The text rendering options to be applied to all subsequent text and glyph drawing operations; NULL to clear current text rendering options. + + + + + Retrieves the properties of an effect. + Microsoft Docs: + The ID of the effect to retrieve properties from. + When this method returns, contains the address of a pointer to the property interface that can be used to query the metadata of the effect. + + + + + Appends an element to the list of children. + Microsoft Docs: + The element to append. + + + + + Draws the transform to the graphics processing unit (GPU)–based Direct2D pipeline. + Microsoft Docs: + The target to which the transform should be written. + The area within the source from which the image should be drawn. + The origin within the target bitmap to which the source data should be drawn. + + + + + The optimization mode for the Gaussian blur effect. + Microsoft Docs: + + + + Applies internal optimizations such as pre-scaling at relatively small radii. Uses linear filtering. + + + Uses the same optimization thresholds as Speed mode, but uses trilinear filtering. + + + Only uses internal optimizations with large blur radii, where approximations are less likely to be visible. Uses trilinear filtering. + + + + Creates a 3D lookup table for mapping a 3-channel input to a 3-channel output. The table data must be provided in 4-channel format. + Microsoft Docs: + Precision of the input lookup table data. + Number of lookup table elements per dimension (X, Y, Z). + Buffer holding the lookup table data. + Size of the lookup table data buffer. + An array containing two values. The first value is the size in bytes from one row (X dimension) of LUT data to the next. + The second value is the size in bytes from one LUT data plane (X and Y dimensions) to the next. + Receives the new lookup table instance. + + + + + Sets the constant buffer for this transform's vertex shader. + Microsoft Docs: + The data applied to the constant buffer + The number of bytes of data in the constant buffer. + + + + + Identifiers for properties of the Saturation effect. + Microsoft Docs: + + + + The saturation of the image. You can set the saturation to a value between 0 and 1. If you set it to 1 the output image is fully saturated. + If you set it to 0 the output image is monochrome. The saturation value is unitless. + + +The type is FLOAT. + +The default is 0.5f. + + + + Interface describing SVG path data. Path data can be set as the 'd' attribute on a 'path' element. + Microsoft Docs: + + + + + Draws a metafile to the command sink using the given source and destination rectangles. + Microsoft Docs: + The metafile to draw. + The rectangle in the target where the metafile will be drawn, relative to the upper left corner (defined in DIPs). If NULL is specified, the destination rectangle is the size of the target. + The rectangle of the source metafile that will be drawn, relative to the upper left corner (defined in DIPs). + If NULL is specified, the source rectangle is the value returned by ID2D1GdiMetafile1::GetSourceBounds. + + + + + Gets the paint color that is used if the paint type is D2D1_SVG_PAINT_TYPE_COLOR. + Microsoft Docs: + The paint color that is used if the paint type is D2D1_SVG_PAINT_TYPE_COLOR. + + + + + Creates an ID2D1GeometryGroup, which is an object that holds other geometries. + Microsoft Docs: + A value that specifies the rule that a composite shape uses to determine whether a given point is part of the geometry. + An array containing the geometry objects to add to the geometry group. The number of elements in this array is indicated by the geometriesCount parameter. + The number of elements in geometries. + When this method returns, contains the address of a pointer to the geometry group created by this method. + + + + + Sets the source rectangle in the image brush. + Microsoft Docs: + The source rectangle that defines the portion of the image to tile. + + + + + Gets either the surface that was specified when the bitmap was created, or the default surface created when the bitmap was created. + Microsoft Docs: + The underlying DXGI surface for the bitmap. + + + + + Sets how the content inside the source rectangle in the image brush will be extended on the x-axis. + Microsoft Docs: + The extend mode on the x-axis of the image. + + + + + Option flags controlling primary conversion performed by CreateImageSourceFromDxgi, if any. + Microsoft Docs: + + + + No primary conversion is performed. + + + Low quality primary conversion is performed. + + + + Identifiers for the properties of the 3D Lookup Table effect. + Microsoft Docs: + + + + The D2D1_LOOKUPTABLE3D_PROP_LUT property is a pointer to an ID2D1LookupTable3D object. The default value is null. + + + The D2D1_LOOKUPTABLE3D_PROP_ALPHA_MODE property is a D2D1_ALPHA_MODE value indicating the alpha mode of the input file. + See the About Alpha Modes section of the Supported Pixel Formats and Alpha Modes topic for additional information. + + + + Option flags for transformed image sources. + Microsoft Docs: + + + + No option flags. + + + Prevents the image source from being automatically scaled (by a ratio of the context DPI divided by 96) while drawn. + + + + Represents a color context that can be used with an ID2D1Bitmap1 object. + Microsoft Docs: + + + + + The interpolation mode the Spot-specular lighting effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Gets the size of the segment data array. + Microsoft Docs: + + + + + Retrieves the render target's current text rendering options. + Microsoft Docs: + When this method returns, textRenderingParamscontains the address of a pointer to the render target's current text rendering options. + + + + + Enters the Direct2D API critical section, if it exists. + Microsoft Docs: + + + + + This interface performs all the same functions as the existing ID2D1CommandSink interface. It also enables access to the new primitive blend modes, MIN and ADD, through its SetPrimitiveBlend1 method. + Microsoft Docs: + + + + + Specifies which ICC rendering intent the Color management effect should use. + Microsoft Docs: + + + + The effect compresses or expands the full color gamut of the image to fill the color gamut of the device, + so that gray balance is preserved but colorimetric accuracy may not be preserved. + + + The effect preserves the chroma of colors in the image at the possible expense of hue and lightness. + + + The effect adjusts colors that fall outside the range of colors the output device renders to the closest color available. It does not preserve the white point. + + + The effect adjusts any colors that fall outside the range that the output device can render to the closest color that can be rendered. The effect does not change the other colors and preserves the white point. + + + + Describes how one geometry object is spatially related to another geometry object. + Microsoft Docs: + + + + The relationship between the two geometries cannot be determined. This value is never returned by any D2D method. + + + The two geometries do not intersect at all. + + + The instance geometry is entirely contained by the passed-in geometry. + + + The instance geometry entirely contains the passed-in geometry. + + + The two geometries overlap but neither completely contains the other. + + + + Converts Direct2D primitives in the passed-in command list into a fixed page representation for use by the print subsystem. + Microsoft Docs: + The command list that contains the rendering operations. + The size of the page to add. + The print ticket stream. + Contains the first label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + Contains the second label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + + + + + Returns the number of inputs to the transform graph. + Microsoft Docs: + + + + + This interface performs all the same functions as the ID2D1DeviceContext2 interface, plus it enables functionality for creating and drawing sprite batches. + Microsoft Docs: + + + + + Gets the label for subsequent drawing operations. + Microsoft Docs: + When this method returns, contains the first label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + When this method returns, contains the second label for subsequent drawing operations. This parameter is passed uninitialized. If NULL is specified, no value is retrieved for this parameter. + + + + + Creates a new ID2D1GdiMetafile object that you can use to replay metafile content. + Microsoft Docs: + A stream object that has the metafile data. + The address of the newly created GDI metafile object. + + + + + Creates a color context. + Microsoft Docs: + The space of color context to create. + A buffer containing the ICC profile bytes used to initialize the color context when space is D2D1_COLOR_SPACE_CUSTOM. For other types, the parameter is ignored and should be set to NULL. + The size in bytes of Profile. + When this method returns, contains the address of a pointer to a new color context object. + + + + + The mode for the Morphology effect. + Microsoft Docs: + + + + The maximum value from each RGB channel in the kernel is used. + + + The minimum value from each RGB channel in the kernel is used. + + + + Sets the constant buffer for this transform's pixel shader. + Microsoft Docs: + The data applied to the constant buffer. + The number of bytes of data in the constant buffer + + + + + Gets the size of the commands array. + Microsoft Docs: + + + + + Returns a boolean indicating whether this element has children. + Microsoft Docs: + + + + + Describes the support for doubles in shaders. + Microsoft Docs: + + + + TRUE is doubles are supported within the shaders. + + + + Supplies the analysis data to an analysis transform. + Microsoft Docs: + The data that the transform will analyze. + The size of the analysis data. + + + + + Sets the maximum capacity of the color glyph cache. + Microsoft Docs: + The maximum capacity of the color glyph cache. + + + + + The interpolation mode to be used with the 2D affine transform effect to scale the image. There are 6 scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Retrieves the number of figures in the path geometry. + Microsoft Docs: + A pointer that receives the number of figures in the path geometry when this method returns. You must allocate storage for this parameter. + + + + + Returns the currently set primitive blend used by the device context. + Microsoft Docs: + + + + + Specifies the center of the gradient ellipse in the brush's coordinate space. + Microsoft Docs: + The center of the gradient ellipse, in the brush's coordinate space. + + + + + The turbulence noise mode for the Turbulence effect. Indicates whether to generate a bitmap based on Fractal Noise or the Turbulence function. + Microsoft Docs: + + + + Computes a sum of the octaves, shifting the output range from [-1, 1], to [0, 1]. + + + Computes a sum of the absolute value of each octave. + + + + Identifiers for properties of the Gaussian blur effect. + Microsoft Docs: + + + + The amount of blur to be applied to the image. You can compute the blur radius of the kernel by multiplying the standard deviation by 3. + The units of both the standard deviation and blur radius are DIPs. A value of zero DIPs disables this effect entirely. + + +The type is FLOAT. + +The default value is 3.0f. + + + The optimization mode. + + +The type is D2D1_GAUSSIANBLUR_OPTIMIZATION. + +The default value is D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED. + + + The mode used to calculate the border of the image, soft or hard. + + +The type is D2D1_GAUSSIANBLUR_OPTIMIZATION. + +The default value is D2D1_BORDER_MODE_SOFT. + + + + Defines the coordinate system used for SVG gradient or clipPath elements. + Microsoft Docs: + + + + The property is set to SVG's 'userSpaceOnUse' value. + + + The property is set to SVG's 'objectBoundingBox' value. + + + + Identifiers for properties of the Blend effect. + Microsoft Docs: + + + + The blend mode used for the effect. + + +The type is D2D1_BLEND_MODE. + +The default value is D2D1_BLEND_MODE_MULTIPLY. + + + + Gets the string length of the name of the specified attribute at the given index. + Microsoft Docs: + The index of the attribute. + Outputs the string length of the name of the specified attribute. + Indicates whether the attribute is set to the inherit value. + + + + + Creates Direct2D resources. + Microsoft Docs: + + + + + Describes the stroke that outlines a shape. + Microsoft Docs: + + + + The cap applied to the start of all the open figures in a stroked geometry. + + + The cap applied to the end of all the open figures in a stroked geometry. + + + The shape at either end of each dash segment. + + + A value that describes how segments are joined. This value is ignored for a vertex if the segment flags specify that the segment should have a smooth join. + + + The limit of the thickness of the join on a mitered corner. This value is always treated as though it is greater than or equal to 1.0f. + + + A value that specifies whether the stroke has a dash pattern and, if so, the dash style. + + + A value that specifies an offset in the dash sequence. A positive dash offset value shifts the dash pattern, in units of stroke width, toward the start of the stroked geometry. A negative dash offset value shifts the dash pattern, in units of stroke width, toward the end of the stroked geometry. + + + + Creates a sequence of lines using the specified points and adds them to the geometry sink. + Microsoft Docs: + A pointer to an array of one or more points that describe the lines to draw. A line is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by BeginFigure) to the first point in the array. if the array contains additional points, a line is drawn from the first point to the second point in the array, from the second point to the third point, and so on. + The number of points in the points array. + + + + + Removes the oldChild from the tree. Children of oldChild remain children of oldChild. + Microsoft Docs: + The child element to be removed. The oldChild element must be an immediate child of this element. + + + + + Implementation of a drawing state block that adds the functionality of primitive blend in addition to already existing antialias mode, transform, tags and text rendering mode. + Microsoft Docs: + + + + + Specifies that the output of the transform in which the render information is encapsulated is or is not cached. + Microsoft Docs: + TRUE if the output of the transform is cached; otherwise, FALSE. + + + + + Identifiers for properties of the Border effect. + Microsoft Docs: + + + + The edge mode in the X direction for the effect. You can set this to clamp, wrap, or mirror. + + +The type is D2D1_BORDER_EDGE_MODE. + +The default value is D2D1_BORDER_EDGE_MODE_CLAMP. + + + The edge mode in the Y direction for the effect. You can set this to clamp, wrap, or mirror. + + +The type is D2D1_BORDER_EDGE_MODE. + +The default value is D2D1_BORDER_EDGE_MODE_CLAMP. + + + + Represents a cubic bezier segment drawn between two points. + Microsoft Docs: + + + + The first control point for the Bezier segment. + + + The second control point for the Bezier segment. + + + The end point for the Bezier segment. + + + + Draws a color bitmap glyph run using one of the bitmap formats. + Microsoft Docs: + Specifies the format of the glyph image. Supported formats are DWRITE_GLYPH_IMAGE_FORMATS_PNG, DWRITE_GLYPH_IMAGE_FORMATS_JPEG, + DWRITE_GLYPH_IMAGE_FORMATS_TIFF, or DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8. This method will result in an error if the color glyph run does not contain the requested format. + + +Only one format can be specified at a time, combinations of flags are not valid input. + The origin of the baseline for the glyph run. + The glyphs to render. + Indicates the measuring method. + Specifies the pixel snapping policy when rendering color bitmap glyphs. + + + + + Defines how to interpolate between colors. + Microsoft Docs: + + + + Colors are interpolated with straight alpha. + + + Colors are interpolated with premultiplied alpha. + + + + Retrieves the limit on the ratio of the miter length to half the stroke's thickness. + Microsoft Docs: + + + + + Creates Direct2D resources. This interface also enables the creation of ID2D1Device5 objects. + Microsoft Docs: + + + + + Retrieves the text-rendering configuration of the drawing state. + Microsoft Docs: + When this method returns, contains the address of a pointer to an IDWriteRenderingParams object that describes the text-rendering configuration of the drawing state. + + + + + Gets the rendering controls that have been applied to the context. + Microsoft Docs: + When this method returns, contains a pointer to the rendering controls for this context. + + + + + This interface performs all the same functions as the existing ID2D1DeviceContext5 interface, plus it enables access to the BlendImage method. + Microsoft Docs: + + + + + Gets the number of points in the array. + Microsoft Docs: + + + + + Represents a set of state and command buffers that are used to render to a target. + Microsoft Docs: + + + + + Gets the string length of the tag name. + Microsoft Docs: + + + + + Gets the bitmap source that this brush uses to paint. + Microsoft Docs: + When this method returns, contains the address to a pointer to the bitmap with which this brush paints. + + + + + Returns the size of the initial viewport. + Microsoft Docs: + + + + + Gets the size of the color profile associated with the bitmap. + Microsoft Docs: + + + + + 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. + Microsoft Docs: + + + + + Retrieve the bounds of the geometry, with an optional applied transform. + Microsoft Docs: + The ink style to be used in determining the bounds of this ink object. + The world transform to be used in determining the bounds of this ink object. + When this method returns, contains the bounds of this ink object. + + + + + Retrieves the center of the gradient ellipse. + Microsoft Docs: + + + + + Return the dots per inch (DPI) of the bitmap. + Microsoft Docs: + The horizontal DPI of the image. You must allocate storage for this parameter. + The vertical DPI of the image. You must allocate storage for this parameter. + + + + + Sets the root element of the document. + Microsoft Docs: + The new root element of the document. + + + + + Describes the drawing state of a device context. + Microsoft Docs: + + + + The antialiasing mode for subsequent nontext drawing operations. + + + The antialiasing mode for subsequent text and glyph drawing operations. + + + A label for subsequent drawing operations. + + + A label for subsequent drawing operations. + + + The transformation to apply to subsequent drawing operations. + + + The blend mode for the device context to apply to subsequent drawing operations. + + + D2D1_UNIT_MODE + + + + Creates a path data object which can be used to set a 'd' attribute on a 'path' element. + Microsoft Docs: + An array of segment data. + Number of items in segmentData. + An array of path commands. + The number of items in commands. + When this method completes, this points to the created path data. + + + + + The interpolation mode used to scale the image in the Bitmap source effect. + Microsoft Docs: + + + + Samples the nearest single point and uses that. Doesn't generate a mipmap. + + + Uses a four point sample and linear interpolation. Doesn't generate a mipmap. + + + Uses a 16 sample cubic kernel for interpolation. Doesn't generate a mipmap. + + + Uses the WIC fant interpolation, the same as the IWICBitmapScaler interface. Doesn't generate a mipmap. + + + Generates mipmap chain in system memory using bilinear interpolation. For each mipmap the effect scales to the nearest multiple of 0.5 using bilinear interpolation + and then scales the remaining amount using linear interpolation. + + + + Creates a color context from a DXGI color space type. It is only valid to use this with the Color Management Effect in 'Best' mode. + Microsoft Docs: + The color space to create the color context from. + The created color context. + + + + + Retrieves the matrix used to transform the ID2D1TransformedGeometry object's source geometry. + Microsoft Docs: + A pointer that receives the matrix used to transform the ID2D1TransformedGeometry object's source geometry. You must allocate storage for this parameter. + + + + + Sets how a specific input to the transform should be handled by the renderer in terms of sampling. + Microsoft Docs: + The index of the input that will have the input description applied. + The description of the input to be applied to the transform. + + + + + Removes a layer from the layer and clip stack. + Microsoft Docs: + + + + + Notifies the implementation of the command sink that drawing is about to commence. + Microsoft Docs: + + + + + Returns a boolean indicating if the attribute is explicitly set on the element. + Microsoft Docs: + The name of the attribute. + Outputs whether the attribute is set to the inherit value. + + + + + Identifiers for properties of the Table transfer effect. + Microsoft Docs: + + + + The list of values used to define the transfer function for the Red channel. + + +The type is FLOAT[]. + +The default is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Red channel. + If you set this to FALSE it applies the RedTableTransfer function to the Red channel. + + +The type is BOOL. + +The default is FALSE. + + + The list of values used to define the transfer function for the Green channel. + + +The type is FLOAT[]. + +The default is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Green channel. + If you set this to FALSE it applies the GreenTableTransfer function to the Green channel. + + +The type is BOOL. + +The default is FALSE. + + + The list of values used to define the transfer function for the Blue channel. + + +The type is FLOAT[]. + +The default is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Blue channel. + If you set this to FALSE it applies the BlueTableTransfer function to the Blue channel. + + +The type is BOOL. + +The default is FALSE. + + + The list of values used to define the transfer function for the Alpha channel. + + +The type is FLOAT[]. + +The default is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Alpha channel. + If you set this to FALSE it applies the AlphaTableTransfer function to the Alpha channel. + + +The type is BOOL. + +The default is FALSE. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. The effect clamps the values before it premultiplies the alpha. + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + +The type is BOOL. + +The default is FALSE. + + + + Represents an SVG viewBox. + Microsoft Docs: + + + + X coordinate of the view box. + + + Y coordinate of the view box. + + + Width of the view box. + + + Height of the view box. + + + + Updates the properties of the specified sprites in this sprite batch. + Microsoft Docs: + The index of the first sprite in this sprite batch to update. + The number of sprites to update with new properties. This determines how many strides into each given array Direct2D will read. + A pointer to an array containing the destination rectangles specifying where to draw the sprites on the destination device context. + A pointer to an array containing the source rectangles specifying the regions of the source bitmap to draw as sprites. + + + +Direct2D will use the entire source bitmap for sprites that are assigned a null value or the InfiniteRectU. + If this parameter is omitted entirely or set to a null value, then Direct2D will use the entire source bitmap for all the updated sprites. + A pointer to an array containing the colors to apply to each sprite. The output color is the result of component-wise multiplication of the source bitmap color and the provided color. + The output color is not clamped. + + + +Direct2D will not change the color of sprites that are assigned a null value. If this parameter is omitted entirely or set to a null value, + then Direct2D will not change the color of any of the updated sprites. + A pointer to an array containing the transforms to apply to each sprite’s destination rectangle. + + + +Direct2D will not transform the destination rectangle of any sprites that are assigned a null value. + If this parameter is omitted entirely or set to a null value, then Direct2D will not transform the destination rectangle of any of the updated sprites. + Specifies the distance, in bytes, between each rectangle in the destinationRectangles array. + If you provide a stride of 0, then the same destination rectangle will be used for each updated sprite. + Specifies the distance, in bytes, between each rectangle in the sourceRectangles array (if that array is given). + If you provide a stride of 0, then the same source rectangle will be used for each updated sprite. + Specifies the distance, in bytes, between each color in the colors array (if that array is given). + If you provide a stride of 0, then the same color will be used for each updated sprite. + Specifies the distance, in bytes, between each transform in the transforms array (if that array is given). + If you provide a stride of 0, then the same transform will be used for each updated sprite. + + + + + Sets the starting coordinates of the linear gradient in the brush's coordinate space. + Microsoft Docs: + The starting two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + + + + + Gets the bounds of the metafile in source space in DIPs. This corresponds to the frame rect in an EMF/EMF+. + Microsoft Docs: + The bounds, in DIPs, of the metafile. + + + + + Creates an image source which shares resources with an original. + Microsoft Docs: + The original image. + Properties for the source image. + Receives the new image source. + + + + + Describes the antialiasing mode used for drawing text. + Microsoft Docs: + + + + Use the system default. See Remarks. + + + Use ClearType antialiasing. + + + Use grayscale antialiasing. + + + Do not use antialiasing. + + + + Retrieves the transform to be applied to this style's nib shape. + Microsoft Docs: + When this method returns, contains a pointer to the transform to be applied to this style's nib shape. + + + + + Gets the interpolation mode of the image brush. + Microsoft Docs: + + + + + Provides values to an SVG glyph for stroke properties. The brush with opacity set to 1 is used as the 'context-stroke'. The opacity of the brush is used as the 'context-stroke-opacity' value. + Microsoft Docs: + Describes how the stroke is painted. A null brush will cause the context-stroke value to be none. + Specifies the 'context-value' for the 'stroke-width' property. + Specifies the 'context-value' for the 'stroke-dasharray' + property. A null value will cause the stroke-dasharray to be set to 'none'. + The the number of dashes in the dash array. + Specifies the 'context-value' for the 'stroke-dashoffset' property. + + + + + Identifiers for properties of the Bitmap source effect. + Microsoft Docs: + + + + The IWICBitmapSource containing the image data to be loaded. + + +The type is IWICBitmapSource. + +The default value is NULL. + + + The scale amount in the X and Y direction. The effect multiplies the width by the X value and the height by the Y value. + This property is a D2D1_VECTOR_2F defined as: (X scale, Y scale). The scale amounts are FLOAT, unitless, and must be positive or 0. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode used to scale the image. + If the mode disables the mipmap, then BitmapSouce will cache the image at the resolution determined by the Scale and EnableDPICorrection properties. + + +The type is D2D1_BITMAPSOURCE_INTERPOLATION_MODE. + +The default value is D2D1_BITMAPSOURCE_INTERPOLATION_MODE_LINEAR. + + + If you set this to TRUE, the effect will scale the input image to convert the DPI reported by IWICBitmapSource to the DPI of the device context. + The effect uses the interpolation mode you set with the InterpolationMode property. If you set this to FALSE, the effect uses a DPI of 96.0 for the output image. + + +The type is BOOL. + +The default value is FALSE. + + + The alpha mode of the output. This can be either premultiplied or straight. + + +The type is D2D1_BITMAPSOURCE_ALPHA_MODE. + +The default value is D2D1_BITMAPSOURCE_ALPHA_MODE_PREMULTIPLIED. + + + A flip and/or rotation operation to be performed on the image. + + +The type is D2D1_BITMAPSOURCE_ORIENTATION. + +The default value is D2D1_BITMAPSOURCE_ORIENTATION_DEFAULT. + + + + Returns a subset of the patches that make up this gradient mesh. + Microsoft Docs: + Index of the first patch to return. + A pointer to the array to be filled with the patch data. + The number of patches to be returned. + + + + + Specifies the optimization mode for the Directional blur effect. + Microsoft Docs: + + + + Applies internal optimizations such as pre-scaling at relatively small radii. Uses linear filtering. + + + Uses the same optimization thresholds as Speed mode, but uses trilinear filtering. + + + Only uses internal optimizations with large blur radii, where approximations are less likely to be visible. Uses trilinear filtering. + + + + Adds a sequence of quadratic Bezier segments as an array in a single call. + Microsoft Docs: + An array of a sequence of quadratic Bezier segments. + A value indicating the number of quadratic Bezier segments in beziers. + + + + + The quality level of the transform for the Color management effect. + Microsoft Docs: + + + + The lowest quality mode. This mode requires feature level 9_1 or above. + + + Normal quality mode. This mode requires feature level 9_1 or above. + + + The best quality mode. This mode requires feature level 10_0 or above, as well as floating point precision buffers. + This mode supports floating point precision as well as extended range as defined in the ICC v4.3 specification. + + + + Creates a clone of this attribute value. On creation, the cloned attribute is not set on any element. + Microsoft Docs: + Specifies the attribute value to clone. + + + + + Identifiers for properties of the Histogram effect. + Microsoft Docs: + + + + Specifies the number of bins used for the histogram. The range of intensity values that fall into a particular bucket depend on the number of specified buckets. + + +The type is UINT32. + +The default is 256. + + + Specifies the channel used to generate the histogram. This effect has a single data output corresponding to the specified channel. + + +The type is D2D1_CHANNEL_SELECTOR. + +The default is D2D1_CHANNEL_SELECTOR_R. + + + The output array. + + +The type is FLOAT[]. + + + + Describes the extend modes and the interpolation mode of an ID2D1BitmapBrush. + Microsoft Docs: + + + + A value that describes how the brush horizontally tiles those areas that extend past its bitmap. + + + A value that describes how the brush vertically tiles those areas that extend past its bitmap. + + + A value that specifies how the bitmap is interpolated when it is scaled or rotated. + + + + Contains the HWND, pixel size, and presentation options for an ID2D1HwndRenderTarget. + Microsoft Docs: + + + + The HWND to which the render target issues the output from its drawing commands. + + + The size of the render target, in pixels. + + + A value that specifies whether the render target retains the frame after it is presented and whether the render target waits for the device to refresh before presenting. + + + + Creates a new device context with no initially assigned target. + Microsoft Docs: + Options for creating the device context. + The created device context. + + + + + Contains the center point, x-radius, and y-radius of an ellipse. + Microsoft Docs: + + + + The center point of the ellipse. + + + The X-radius of the ellipse. + + + The Y-radius of the ellipse. + + + + Represents the base interface for all of the transforms implemented by the transform author. + Microsoft Docs: + + + + + Sets the maximum amount of texture memory Direct2D accumulates before it purges the image caches and cached texture allocations. + Microsoft Docs: + The new maximum texture memory in bytes. + + + + + Gets the current transform of the render target. + Microsoft Docs: + When this returns, contains the current transform of the render target. This parameter is passed uninitialized. + + + + + The edge mode for the Border effect. + Microsoft Docs: + + + + Repeats the pixels from the edges of the image. + + + Uses pixels from the opposite end edge of the image. + + + Reflects pixels about the edge of the image. + + + + Describes a geometric path that can contain lines, arcs, cubic Bezier curves, and quadratic Bezier curves. + Microsoft Docs: + + + + + Sets the given input image by index. + Microsoft Docs: + The index of the image to set. + The input image to set. + Whether to invalidate the graph at the location of the effect input + + + + + Provides methods to allow a blend operation to be inserted into a transform graph. + Microsoft Docs: + + + + + Creates a Direct2D effect for the specified class ID. + Microsoft Docs: + The built-in or registered effect ID to create the effect. See Built-in Effects for a list of effect IDs. + When this method returns, contains the address of a pointer to the effect. + + + + + Retrieves a set simple color profile. + Microsoft Docs: + Pointer to a D2D1_SIMPLE_COLOR_PROFILE that will contain the simple color profile when the method returns. + + + + + Identifiers for properties of the Spot-diffuse lighting effect. + Microsoft Docs: + + + + The light position of the point light source. The property is a D2D1_VECTOR_3F defined as (x, y, z). The units are in device-independent pixels (DIPs) and are unbounded. + + +The type is D2D1_VECTOR_3F. + + +The default value is {0.0f, 0.0f, 0.0f}. + + + Where the spot light is focused. The property is exposed as a D2D1_VECTOR_3F with – (x, y, z). The units are in DIPs and the values are unbounded. + + +The type is D2D1_VECTOR_3F. + + +The default value is {0.0f, 0.0f, 0.0f}. + + + The focus of the spot light. This property is unitless and is defined between 0 and 200. + + +The type is FLOAT. + +The default value is 1.0f. + + + The cone angle that restricts the region where the light is projected. No light is projected outside the cone. The limiting cone angle is the angle between the spot light axis (the axis between the LightPosition and PointsAt properties) and the spot light cone. This property is defined in degrees and must be between 0 to 90 degrees. + + +The type is FLOAT. + +The default value is 90.0f. + + + The ratio of diffuse reflection to amount of incoming light. This property must be between 0 and 10,000 and is unitless. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction. The surface scale is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a Vector 3 – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f} + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y direction. This property maps to the dx and dy values in the Sobel gradient. + This property is a D2D1_VECTOR_2F(Kernel Unit Length X, Kernel Unit Length Y) and is defined in (DIPs/Kernel Unit). + The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_SPOTDIFFUSE_SCALE_MODE. + + +The default value is D2D1_SPOTDIFFUSE_SCALE_MODE_LINEAR. + + + + Returns the number of dashes in the dash array. + Microsoft Docs: + + + + + Values for the D2D1_EDGEDETECTION_PROP_MODE property of the Edge Detection effect. + Microsoft Docs: + + + + Indicates the Sobel operator should be used for edge detection. + + + Indicates the Prewitt operator should be used for edge detection. + + + + Specifies the bitmap source that this brush uses to paint. + Microsoft Docs: + The bitmap source used by the brush. + + + + + Defines the type of SVG POD attribute to set or get. + Microsoft Docs: + + + + The attribute is a FLOAT. + + + The attribute is a D2D1_COLOR_F. + + + The attribute is a D2D1_FILL_MODE. + + + The attribute is a D2D1_SVG_DISPLAY. + + + The attribute is a D2D1_SVG_OVERFLOW. + + + The attribute is a D2D1_SVG_LINE_CAP. + + + The attribute is a D2D1_SVG_LINE_JOIN. + + + The attribute is a D2D1_SVG_VISIBILITY. + + + The attribute is a D2D1_MATRIX_3X2_F. + + + The attribute is a D2D1_SVG_UNIT_TYPE. + + + The attribute is a D2D1_EXTEND_MODE. + + + The attribute is a D2D1_SVG_PRESERVE_ASPECT_RATIO. + + + The attribute is a D2D1_SVG_VIEWBOX. + + + The attribute is a D2D1_SVG_LENGTH. + + + + Identifiers for properties of the Point-specular lighting effect. + Microsoft Docs: + + + + The light position of the point light source. The property is a D2D1_VECTOR_3F defined as (x, y, z). The units are in device-independent pixels (DIPs) and the values are unitless and unbounded. + + +The type is D2D1_VECTOR_3F. + +The default value is {0.0f, 0.0f, 0.0f}. + + + The exponent for the specular term in the Phong lighting equation. A larger value corresponds to a more reflective surface. This value is unitless and must be between 1.0 and 128. + + +The type is FLOAT. + +The default value is 1.0f. + + + The ratio of specular reflection to the incoming light. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction for generating a height map. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a D2D1_VECTOR_3F – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f}. + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y directions. This property maps to the dx and dy values in the Sobel gradient. + This property is a D2D1_VECTOR_2F(Kernel Unit Length X, Kernel Unit Length Y) and is defined in (DIPs/Kernel Unit). + The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_POINTSPECULAR_SCALE_MODE. + +The default value is D2D1_POINTSPECULAR_SCALE_MODE_LINEAR. + + + + Represents an object that can receive drawing commands. Interfaces that inherit from ID2D1RenderTarget render the drawing commands they receive in different ways. + Microsoft Docs: + + + + + Renders a given gradient mesh to the target. + Microsoft Docs: + The gradient mesh to be rendered. + + + + + Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the ID2D1Device3 interface. It also enables the creation of ID2D1DeviceContext4 objects. + Microsoft Docs: + + + + + Sets the antialiasing mode of the render target. The antialiasing mode applies to all subsequent drawing operations, excluding text and glyph drawing operations. + Microsoft Docs: + The antialiasing mode for future drawing operations. + + + + + Creates Direct2D resources. This interface performs all the same functions as the ID2D1Factory6 interface, plus it enables the creation of ID2D1Device6 objects. + Microsoft Docs: + + + + + Contains the dimensions and corner radii of a rounded rectangle. + Microsoft Docs: + + + + The coordinates of the rectangle. + + + The x-radius for the quarter ellipse that is drawn to replace every corner of the rectangle. + + + The y-radius for the quarter ellipse that is drawn to replace every corner of the rectangle. + + + + Describes image brush features. + Microsoft Docs: + + + + The source rectangle in the image space from which the image will be tiled or interpolated. + + + The extend mode in the image x-axis. + + + The extend mode in the image y-axis. + + + The interpolation mode to use when scaling the image brush. + + + + Gets the name of the attribute at the given index. + Microsoft Docs: + The index of the attribute. + Outputs the name of the attribute. + Length of the string returned in the name argument. + Outputs whether the attribute is set to the inherit value. + + + + + Removes points from the end of the array. + Microsoft Docs: + Specifies how many points to remove. + + + + + Describes features of an effect. + Microsoft Docs: + + + + The effect whose input connection is being specified. + + + The input index of the effect that is being considered. + + + The amount of data that would be available on the input. This can be used to query this information when the data is not yet available. + + + + Specifies the options with which the Direct2D device, factory, and device context are created. + Microsoft Docs: + + + + The threading mode with which the corresponding root objects will be created. + + + The debug level that the root objects should be created with. + + + The device context options that the root objects should be created with. + + + + Loads the given shader by its unique ID. + Microsoft Docs: + The unique id that identifies the shader. + The buffer that contains the shader to register. + The size of the shader buffer in bytes. + + + + + Creates a color context from an IWICColorContext. The D2D1ColorContext space of the resulting context varies, see Remarks for more info. + Microsoft Docs: + The IWICColorContext used to initialize the color context. + When this method returns, contains the address of a pointer to a new color context. + + + + + Retrieves the rectangle that describes the rectangle geometry's dimensions. + Microsoft Docs: + Contains a pointer to a rectangle that describes the rectangle geometry's dimensions when this method returns. You must allocate storage for this parameter. + + + + + Represents an ellipse. + Microsoft Docs: + + + + + Specifies a value for the SVG visibility property. + Microsoft Docs: + + + + The element is visible. + + + The element is invisible. + + + + Represents a bitmap that has been bound to an ID2D1RenderTarget. + Microsoft Docs: + + + + + This interface performs all the same functions as the ID2D1DeviceContext3 interface, plus it enables functionality for handling new types of color font glyphs. + Microsoft Docs: + + + + + Creates a new ID2D1DeviceContext3 from this Direct2D device. + Microsoft Docs: + The options to be applied to the created device context. + When this method returns, contains a pointer to the new device context. + + + + + Ends the current figure; optionally, closes it. + Microsoft Docs: + A value that indicates whether the current figure is closed. If the figure is closed, a line is drawn between the current point and the start point specified by BeginFigure. + + + + + Allows a transform to state how it would map a rectangle requested on its output to a set of sample rectangles on its input. + Microsoft Docs: + The output rectangle from which the inputs must be mapped. + The corresponding set of inputs. The inputs will directly correspond to the transform inputs. + The number of inputs specified. Direct2D guarantees that this is equal to the number of inputs specified on the transform. + + + + + Creates Direct2D resources. This interface also enables the creation of ID2D1Device3 objects. + Microsoft Docs: + + + + + Specifies whether an arc should be greater than 180 degrees. + Microsoft Docs: + + + + An arc's sweep should be 180 degrees or less. + + + An arc's sweep should be 180 degrees or greater. + + + + Identifiers for the properties of the Arithmetic composite effect. + Microsoft Docs: + + + + The coefficients for the equation used to composite the two input images. The coefficients are unitless and unbounded. + + +Type is D2D1_VECTOR_4F. + +Default value is {1.0f, 0.0f, 0.0f, 0.0f}. + + + The effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. + If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + + +Type is BOOL. + +Default value is FALSE. + + + + Gets the first child of this element. + Microsoft Docs: + Outputs the first child of this element. + + + + + Represents a producer of pixels that can fill an arbitrary 2D plane. + Microsoft Docs: + + + + + Identifiers for properties of the Hue rotate effect. + Microsoft Docs: + + + + The angle to rotate the hue, in degrees. + + +The type is FLOAT. + +The default is 0.0f. + + + + Specifies how a brush paints areas outside of its normal content area. + Microsoft Docs: + + + + Repeat the edge pixels of the brush's content for all regions outside the normal content area. + + + Repeat the brush's content. + + + The same as D2D1_EXTEND_MODE_WRAP, except that alternate tiles of the brush's content are flipped. (The brush's normal content is drawn untransformed.) + + + + Creates a new device context from a Direct2D device. + Microsoft Docs: + The options to be applied to the created device context. + When this method returns, contains the address of a pointer to the new device context. + + + + + Draws an SVG document. + Microsoft Docs: + The SVG document to draw. + + + + + Gets the given input image by index. + Microsoft Docs: + The index of the image to retrieve. + When this method returns, contains the address of a pointer to the image that is identified by Index. + + + + + Represents a collection of D2D1_GRADIENT_STOP objects for linear and radial gradient brushes. It provides get methods for all the new parameters added to the gradient stop collection. + Microsoft Docs: + + + + + Sets the size of the initial viewport. + Microsoft Docs: + The size of the viewport. + + + + + Creates a color context by loading it from the specified filename. The profile bytes are the contents of the file specified by Filename. + Microsoft Docs: + The path to the file containing the profile bytes to initialize the color context with. + When this method returns, contains the address of a pointer to a new color context. + + + + + Provides factory methods and other state management for effect and transform authors. + Microsoft Docs: + + + + + The command sink is implemented by you for an application when you want to receive a playback of the commands recorded in a command list. + Microsoft Docs: + + + + + Enables creation and drawing of geometry realization objects. + Microsoft Docs: + + + + + Sets the resource texture corresponding to the given shader texture index. + Microsoft Docs: + The index of the texture to be bound to the pixel shader. + The created resource texture. + + + + + Retrieves the offset of the gradient origin relative to the gradient ellipse's center. + Microsoft Docs: + + + + + Specifies the interpolation mode for the YCbCr effect. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + The interpolation mode the Point-specular lighting effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Describes mapped memory from the ID2D1Bitmap1::Map API. + Microsoft Docs: + + + + The size in bytes of an individual scanline in the bitmap. + + + The data inside the bitmap. + + + + Specifies a value for the SVG stroke-linecap property. + Microsoft Docs: + + + + The property is set to SVG's 'butt' value. + + + The property is set to SVG's 'square' value. + + + The property is set to SVG's 'round' value. + + + + Retrieves the bitmap for this render target. The returned bitmap can be used for drawing operations. + Microsoft Docs: + When this method returns, contains the address of a pointer to the bitmap for this render target. This bitmap can be used for drawing operations. + + + + + Gets a value that describes the stroke's dash pattern. + Microsoft Docs: + + + + + Gets the color context information associated with the bitmap. + Microsoft Docs: + When this method returns, contains the address of a pointer to the color context interface associated with the bitmap. + + + + + Identifiers for properties of the Edge Detection effect. + Microsoft Docs: + + + + The D2D1_EDGEDETECTION_PROP_STRENGTH property is a float value modulating the response of the edge detection filter. A low strength value means that weaker edges will get filtered out, + while a high value means stronger edges will get filtered out. The allowed range is 0.0 to 1.0. The default value is 0.5. + + + The D2D1_EDGEDETECTION_PROP_BLUR_RADIUS property is a float value specifying the amount of blur to apply. Applying blur is used to remove high frequencies and reduce phantom edges. + The allowed range is 0.0 to 10.0. The default value is 0.0 (no blur applied). + + + The D2D1_EDGEDETECTION_PROP_MODE property is a D2D1_EDGEDETECTION_MODE enumeration value which mode to use for edge detection. + The default value is D2D1_EDGEDETECTION_MODE_SOBEL. + + + The D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES property is a boolean value. Edge detection only applies to the RGB channels, the alpha channel is ignored for purposes of detecting edges. + If D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES is false, the output edges is fully opaque. If D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES is true, the input opacity is preserved. + The default value is false. + + + The D2D1_EDGEDETECTION_PROP_ALPHA_MODE property is a D2D1_ALPHA_MODE enumeration value indicating the alpha mode of the input file. + If the input is not opaque, this value is used to determine whether to unpremultiply the inputs. + See the About Alpha Modes section of the Supported Pixel Formats and Alpha Modes topic for additional information. + + The default value is D2D1_ALPHA_MODE_PREMULTIPLIED. + + + + Returns the requested fill parameters. + Microsoft Docs: + Describes how the area is painted. + + + + + Defines the direction that an elliptical arc is drawn. + Microsoft Docs: + + + + Arcs are drawn in a counterclockwise (negative-angle) direction. + + + Arcs are drawn in a clockwise (positive-angle) direction. + + + + Indicates to the command sink a rectangle to be filled. + Microsoft Docs: + The rectangle to fill. + The brush with which to fill the rectangle. + + + + + Identifiers for properties of the Contrast effect. + Microsoft Docs: + + + + The D2D1_CONTRAST_PROP_CONTRAST property is a float value indicating the amount by which to adjust the contrast of the image. Negative values reduce contrast, while positive values increase contrast. + Minimum value is -1.0f, maximum value is 1.0f. The default value for the property is 0.0f. + + + The D2D1_CONTRAST_PROP_CLAMP_INPUT property is a boolean value indicating whether or not to clamp the input to [0.0, 1.0]. The default value for the property is FALSE. + + + + Specifies a value for the SVG overflow property. + Microsoft Docs: + + + + The element is not clipped to its viewport. + + + The element is clipped to its viewport. + + + + Specifies a label for subsequent drawing operations. + Microsoft Docs: + A label to apply to subsequent drawing operations. + A label to apply to subsequent drawing operations. + + + + + Identifiers for properties of the Displacement map effect. + Microsoft Docs: + + + + Multiplies the intensity of the selected channel from the displacement image. The higher you set this property, the more the effect displaces the pixels. + + +The type is FLOAT. + +The default value is 0.0f. + + + The effect extracts the intensity from this color channel and uses it to spatially displace the image in the X direction. + + +The type is D2D1_CHANNEL_SELECTOR. + +The default value is D2D1_CHANNEL_SELECTOR_A + + + The effect extracts the intensity from this color channel and uses it to spatially displace the image in the Y direction. + + +The type is D2D1_CHANNEL_SELECTOR. + +The default value is D2D1_CHANNEL_SELECTOR_A + + + + Sets the tags that correspond to the tags in the command sink. + Microsoft Docs: + The first tag to associate with the primitive. + The second tag to associate with the primitive. + + + + + Identifiers for properties of the Directional blur effect. + Microsoft Docs: + + + + The amount of blur to be applied to the image. You can compute the blur radius of the kernel by multiplying the standard deviation by 3. + The units of both the standard deviation and blur radius are DIPs. A value of 0 DIPs disables this effect. + + +The type is FLOAT. + +The default value is 3.0f. + + + The angle of the blur relative to the x-axis, in the counterclockwise direction. The units are specified in degrees. + + +The blur kernel is first generated using the same process as for the Gaussian blur effect. The kernel values are then transformed according to the blur angle. + +The type is FLOAT. + +The default value is 0.0f. + + + The optimization mode. See Optimization modes for more info. + + +The type is D2D1_DIRECTIONALBLUR_OPTIMIZATION. + +The default value is D2D1_DIRECTIONALBLUR_OPTIMIZATION_BALANCED. + + + The mode used to calculate the border of the image, soft or hard. See Border modes for more info. + + +The type is D2D1_BORDER_MODE. + +The default value is D2D1_BORDER_MODE_SOFT. + + + + Represents a geometry that has been transformed. + Microsoft Docs: + + + + + Gets the maximum capacity of the color glyph cache. + Microsoft Docs: + + + + + Removes the last axis-aligned clip from the render target. After this method is called, the clip is no longer applied to subsequent drawing operations. + Microsoft Docs: + + + + + Loads the given shader by its unique ID. + Microsoft Docs: + The unique id that identifies the shader. + The buffer that contains the shader to register. + The size of the shader buffer in bytes. + + + + + Gets the options used in creating the bitmap. + Microsoft Docs: + + + + + Removes data from the end of the segment data array. + Microsoft Docs: + Specifies how much data to remove. + + + + + Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the ID2D1Device2 interface. It also enables the creation of ID2D1DeviceContext3 objects. + Microsoft Docs: + + + + + Copies the specified region from the specified bitmap into the current bitmap. + Microsoft Docs: + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The bitmap to copy from. + The area of bitmap to copy. + + + + + Creates a vertex buffer or finds a standard vertex buffer and optionally initializes it with vertices. + Microsoft Docs: + The properties used to describe the vertex buffer and vertex shader. + The unique id that identifies the vertex buffer. + The properties used to define a custom vertex buffer. If you use a built-in vertex shader, you don't have to specify this property. + The returned vertex buffer. + + + + + Updates the specified segments in this ink object with new control points. + Microsoft Docs: + The index of the first segment in this ink object to update. + A pointer to the array of segment data to be used in the update. + The number of segments in this ink object that will be updated with new data. Note that segmentsCount must be less than or equal to the number of segments in the ink object minus startSegment. + + + + + A specialized implementation of the Shantzis calculations to a transform implemented on the GPU. + Microsoft Docs: + + + + + Retrieves the pixel format and alpha mode of the bitmap. + Microsoft Docs: + + + + + Paints the interior of the specified geometry. + Microsoft Docs: + The geometry to paint. + The brush used to paint the geometry's interior. + The opacity mask to apply to the geometry, or NULL for no opacity mask. If an opacity mask (the opacityBrush parameter) is specified, brush must be an ID2D1BitmapBrush that has its x- and y-extend modes set to D2D1_EXTEND_MODE_CLAMP. For more information, see the Remarks section. + + + + + Sets a new transform. + Microsoft Docs: + The transform to be set. + + + + + Retrieves a value that specifies how far in the dash sequence the stroke will start. + Microsoft Docs: + + + + + Streams the contents of the command list to the specified command sink. + Microsoft Docs: + The sink into which the command list will be streamed. + + + + + Loads the given shader by its unique ID. + Microsoft Docs: + The unique id that identifies the shader. + The buffer that contains the shader to register. + The size of the shader buffer in bytes. + + + + + Provides factory methods and other state management for effect and transform authors. + Microsoft Docs: + + + + + Gets the invalid rectangles that have accumulated since the last time the effect was drawn and EndDraw was then called on the device context. + Microsoft Docs: + The effect to get the invalid rectangles from. + An array of D2D1_RECT_F structures. You must allocate this to the correct size. You can get the count of the invalid rectangles using the GetEffectInvalidRectangleCount method. + The number of rectangles to get. + + + + + Populates an ID2D1Mesh object with triangles. + Microsoft Docs: + + + + + Represents a producer of pixels that can fill an arbitrary 2D plane. + Microsoft Docs: + + + + + Gets the antialiasing mode, transform, tags, primitive blend, and unit mode portion of the drawing state. + Microsoft Docs: + When this method returns, contains the antialiasing mode, transform, tags, primitive blend, and unit mode portion of the drawing state. You must allocate storage for this parameter. + + + + + Retrieves a rounded rectangle that describes this rounded rectangle geometry. + Microsoft Docs: + A pointer that receives a rounded rectangle that describes this rounded rectangle geometry. You must allocate storage for this parameter. + + + + + Identifiers for properties of the Linear transfer effect. + Microsoft Docs: + + + + The Y-intercept of the linear function for the Red channel. + + +The type is FLOAT. + +The default is 0.0f. + + + The slope of the linear function for the Red channel. + + +The type is FLOAT. + +The default is 1.0f. + + + If you set this to TRUE the effect does not apply the transfer function to the Red channel. + If you set this to FALSE the effect applies the RedLinearTransfer function to the Red channel. + + +The type is BOOL. + +The default is FALSE. + + + The Y-intercept of the linear function for the Green channel. + + +The type is FLOAT. + +The default is 0.0f. + + + The slope of the linear function for the Green channel. + + +The type is FLOAT. + +The default is 1.0f. + + + If you set this to TRUE the effect does not apply the transfer function to the Green channel. + If you set this to FALSE the effect applies the GreenLinearTransfer function to the Green channel. + + +The type is BOOL. + +The default is FALSE. + + + The Y-intercept of the linear function for the Blue channel. + + +The type is FLOAT. + +The default is 0.0f. + + + The slope of the linear function for the Blue channel. + + +The type is FLOAT. + +The default is 1.0f. + + + If you set this to TRUE the effect does not apply the transfer function to the Blue channel. + If you set this to FALSE the effect applies the BlueLinearTransfer function to the Blue channel. + + +The type is BOOL. + +The default is FALSE. + + + The Y-intercept of the linear function for the Alpha channel. + + +The type is FLOAT. + +The default is 0.0f. + + + The slope of the linear function for the Alpha channel. + + +The type is FLOAT. + +The default is 0.0f. + + + If you set this to TRUE the effect does not apply the transfer function to the Alpha channel. + If you set this to FALSE the effect applies the AlphaLinearTransfer function to the Alpha channel. + + +The type is BOOL. + +The default is FALSE. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. + The effect clamps the values before it premultiplies the alpha . + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, but other effects and + the output surface may clamp the values if they are not of high enough precision. + +The type is BOOL. + +The default is FALSE. + + + + Gets the string length of the element id which acts as the paint server. This id is used if the paint type is D2D1_SVG_PAINT_TYPE_URI. + Microsoft Docs: + + + + + Creates a new Direct2D device from the given IDXGIDevice. + Microsoft Docs: + The IDXGIDevice from which to create the Direct2D device. + The created device. + + + + + Identifiers for properties of the Highlights and Shadows effect. + Microsoft Docs: + + + + The D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS property is a float value indicating how much to increase or decrease highlights. The allowed range is -1.0 to 1.0. The default value is 0.0. + + + The D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS property is a float value indicating how much to increase or decrease shadows. The allowed range is -1.0 to 1.0. The default value is 0.0. + + + The D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY property is a float value indicating how much to increase or decrease clarity. The allowed range is -1.0 to 1.0. The default value is 0.0. + + + The D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA property is a D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA enumeration value + indicating the gamma of the input image. The Highlights and Shadows effect works in linear gamma space, so if the input image is know to be linear, the D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR value should be used to prevent sRGB to linear conversions from being performed. + + + The D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS property is a float value controlling the size of the region used around a pixel to classify the pixel as highlight or shadow. Lower values result in more localized adjustments. + The allowed range is 0.0 to 10.0. The default value is 1.25. + + + + This interface is used to describe a GPU rendering pass on a vertex or pixel shader. It is passed to ID2D1DrawTransform. + Microsoft Docs: + + + + + Retrieves the x-radius of the gradient ellipse. + Microsoft Docs: + + + + + This specifies options that apply to the device context for its lifetime. + Microsoft Docs: + + + + The device context is created with default options. + + + Distribute rendering work across multiple threads. Refer to Improving the performance of Direct2D apps for additional notes on the use of this flag. + + + + Stops redirecting drawing operations to the layer that is specified by the last PushLayer call. + Microsoft Docs: + + + + + Specifies the different methods by which two geometries can be combined. + Microsoft Docs: + + + + The two regions are combined by taking the union of both. Given two geometries, A and B, the resulting geometry is geometry A + geometry B. + + + The two regions are combined by taking their intersection. The new area consists of the overlapping region between the two geometries. + + + The two regions are combined by taking the area that exists in the first region but not the second and the area that exists in the second region but not the first. Given two geometries, A and B, the new region consists of (A-B) + (B-A). + + + The second region is excluded from the first. Given two geometries, A and B, the area of geometry B is removed from the area of geometry A, producing a region that is A-B. + + + + Converts Direct2D primitives stored in an ID2D1CommandList into a fixed page representation. The print sub-system then consumes the primitives. + Microsoft Docs: + + + + + Creates and returns an offset transform. + Microsoft Docs: + The offset amount. + When this method returns, contains the address of a pointer to an offset transform object. + + + + + A container for 3D lookup table data that can be passed to the LookupTable3D effect. + Microsoft Docs: + + + + + Retrieves the starting point for this ink object. + Microsoft Docs: + + + + + Closes the geometry sink, indicates whether it is in an error state, and resets the sink's error state. + Microsoft Docs: + + + + + This method streams the contents of the command to the given metafile sink. + Microsoft Docs: + The sink into which Direct2D will call back. + + + + + Specifies how the layer contents should be prepared. + Microsoft Docs: + + + + Default layer behavior. A premultiplied layer target is pushed and its contents are cleared to transparent black. + + + The layer is not cleared to transparent black. + + + The layer is always created as ignore alpha. All content rendered into the layer will be treated as opaque. + + + + Draws the outline of the specified geometry using the specified stroke style. + Microsoft Docs: + The geometry to draw. + The brush used to paint the geometry's stroke. + The width of the stroke, in device-independent pixels. The value must be greater than or equal to 0.0f. If this parameter isn't specified, it defaults to 1.0f. The stroke is centered on the line. + The style of stroke to apply to the geometry's outline, or NULL to paint a solid stroke. + + + + + Closes the sink and returns its error status. + Microsoft Docs: + + + + + This interface performs all the same functions as the ID2D1DeviceContext4 interface, plus it enables the creation of color contexts and Svg documents. + Microsoft Docs: + + + + + This creates a blend transform that can be inserted into a transform graph. + Microsoft Docs: + The number of inputs to the blend transform. + Describes the blend transform that is to be created. + The returned blend transform. + + + + + Describes whether a render target uses hardware or software rendering, or if Direct2D should select the rendering mode. + Microsoft Docs: + + + + The render target uses hardware rendering, if available; otherwise, it uses software rendering. + + + The render target uses software rendering only. + + + The render target uses hardware rendering only. + + + + Returns the DXGI device associated with this Direct2D device. + Microsoft Docs: + The DXGI device associated with this Direct2D device. + + + + + Retrieves the source image used to create the transformed image source. + Microsoft Docs: + Retrieves the source image used to create the transformed image source. + + + + + Describes the drawing state of a render target. + Microsoft Docs: + + + + The antialiasing mode for subsequent nontext drawing operations. + + + The antialiasing mode for subsequent text and glyph drawing operations. + + + A label for subsequent drawing operations. + + + A label for subsequent drawing operations. + + + The transformation to apply to subsequent drawing operations. + + + + This method is called once for each record stored in a metafile. + Microsoft Docs: + The type of the record. + The data for the record. + The byte size of the record data. + + + + + Tracks a transform-created resource texture. + Microsoft Docs: + + + + + Renders a given geometry realization to the target with the specified brush. + Microsoft Docs: + The geometry realization to be rendered. + The brush to render the realization with. + + + + + Identifiers for the properties of the 3D perspective transform effect. + Microsoft Docs: + + + + The interpolation mode the effect uses on the image. There are 5 scale modes that range in quality and speed. + + +Type is D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE. + +Default value is D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR. + + + The mode used to calculate the border of the image, soft or hard. See Border modes for more info. + + +Type is D2D1_BORDER_MODE. + +Default value is D2D1_BORDER_MODE_SOFT. + + + The distance from the PerspectiveOrigin to the projection plane. The value specified in DIPs and must be greater than 0. + + +Type is FLOAT. + +Default value is 1000.0f. + + + The X and Y location of the viewer in the 3D scene. This property is a D2D1_VECTOR_2F defined as: (point X, point Y). The units are in DIPs. + You set the Z value with the Depth property. + + +Type is D2D1_VECTOR_2F. + +Default value is {0.0f, 0.0f}. + + + A translation the effect performs before it rotates the projection plane. This property is a D2D1_VECTOR_3F defined as: (X, Y, Z). The units are in DIPs. + + +Type is D2D1_VECTOR_3F. + +Default value is {0.0f, 0.0f, 0.0f}. + + + A translation the effect performs after it rotates the projection plane. This property is a D2D1_VECTOR_3F defined as: (X, Y, Z). The units are in DIPs. + + +Type is D2D1_VECTOR_3F. + +Default value is {0.0f, 0.0f, 0.0f}. + + + The center point of the rotation the effect performs. This property is a D2D1_VECTOR_3F defined as: (X, Y, Z). The units are in DIPs. + + +Type is D2D1_VECTOR_3F. + +Default value is {0.0f, 0.0f, 0.0f}. + + + The angles of rotation for each axis. This property is a D2D1_VECTOR_3F defined as: (X, Y, Z). The units are in degrees. + + +Type is D2D1_VECTOR_3F. + +Default value is {0.0f, 0.0f, 0.0f}. + + + + Paints an area with a bitmap. + Microsoft Docs: + + + + + The unit mode changes the meaning of subsequent units from device-independent pixels (DIPs) to pixels or the other way. The command sink does not record a DPI, this is implied by the playback context or other playback interface such as ID2D1PrintControl. + Microsoft Docs: + The enumeration that specifies how units are to be interpreted. + + + + + Contains the control point and end point for a quadratic Bezier segment. + Microsoft Docs: + + + + The control point of the quadratic Bezier segment. + + + The end point of the quadratic Bezier segment. + + + + Sets the render information used to specify the compute shader pass. + Microsoft Docs: + The render information object to set. + + + + + Gets the world-space bounds in DIPs of the glyph run using the device context DPI. + Microsoft Docs: + The origin of the baseline for the glyph run. + The glyph run to render. + The DirectWrite measuring mode that indicates how glyph metrics are used to measure text when it is formatted. + The bounds of the glyph run in DIPs and in world space. + + + + + Gets the bounds of the metafile, in device-independent pixels (DIPs), as reported in the metafile’s header. + Microsoft Docs: + The bounds, in DIPs, of the metafile. + + + + + Returns the HWND associated with this render target. + Microsoft Docs: + + + + + Gets the paint type. + Microsoft Docs: + + + + + Creates a new, empty sprite batch. After creating a sprite batch, use ID2D1SpriteBatch::AddSprites to add sprites to it, then use ID2D1DeviceContext3::DrawSpriteBatch to draw it. + Microsoft Docs: + When this method returns, contains a pointer to a new, empty sprite batch to be populated by the app. + + + + + Sets the offset in the current offset transform. + Microsoft Docs: + The new offset to apply to the offset transform. + + + + + Gets the target currently associated with the device context. + Microsoft Docs: + When this method returns, contains the address of a pointer to the target currently associated with the device context. + + + + + Describes a node in a transform topology. + Microsoft Docs: + + + + + Describes the shape that joins two lines or segments. + Microsoft Docs: + + + + Regular angular vertices. + + + Beveled vertices. + + + Rounded vertices. + + + Regular angular vertices unless the join would extend beyond the miter limit; otherwise, beveled vertices. + + + + Indicates whether the format is supported by the device context. + Microsoft Docs: + The DXGI format to check. + + + + + Specifies the pixel snapping policy when rendering color bitmap glyphs. + Microsoft Docs: + + + + Color bitmap glyph positions are snapped to the nearest pixel if the bitmap + resolution matches that of the device context. + + + Color bitmap glyph positions are not snapped. + + + + Contains the starting point and endpoint of the gradient axis for an ID2D1LinearGradientBrush. + Microsoft Docs: + + + + In the brush's coordinate space, the starting point of the gradient axis. + + + In the brush's coordinate space, the endpoint of the gradient axis. + + + + Used to specify the blend mode for all of the Direct2D blending operations. + Microsoft Docs: + + + + The standard source-over-destination blend mode. + + + The destination is rendered over the source. + + + Performs a logical clip of the source pixels against the destination pixels. + + + The inverse of the D2D1_COMPOSITE_MODE_SOURCE_IN operation. + + + This is the logical inverse to D2D1_COMPOSITE_MODE_SOURCE_IN. + + + The is the logical inverse to D2D1_COMPOSITE_MODE_DESTINATION_IN. + + + Writes the source pixels over the destination where there are destination pixels. + + + The logical inverse of D2D1_COMPOSITE_MODE_SOURCE_ATOP. + + + The source is inverted with the destination. + + + The channel components are summed. + + + The source is copied to the destination; the destination pixels are ignored. + + + Equivalent to D2D1_COMPOSITE_MODE_SOURCE_COPY, but pixels outside of the source bounds are unchanged. + + + Destination colors are inverted according to a source mask. + + + + This interface performs all the same functions as the existing ID2D1CommandSink2 interface. It also enables access to sprite batch rendering. + Microsoft Docs: + + + + + Provides values to an SVG glyph for fill. + Microsoft Docs: + Describes how the area is painted. A null brush will cause the context-fill value to come from + the defaultFillBrush. If the defaultFillBrush is also null, the context-fill value will be 'none'. + To set the ‘context-fill’ value, this method uses the provided brush with its opacity set to 1. To set the ‘context-fill-opacity’ value, this method uses the opacity of the provided brush. + + + + + Sets a new primitive blend mode. Allows access to the MAX primitive blend mode. + Microsoft Docs: + The primitive blend that will apply to subsequent primitives. + + + + + Gets a value that specifies how the ends of each dash are drawn. + Microsoft Docs: + + + + + A developer implemented interface that allows a metafile to be replayed. + Microsoft Docs: + + + + + Returns the number of segments in this ink object. + Microsoft Docs: + + + + + Identifiers for properties of the Distant-diffuse lighting effect. + Microsoft Docs: + + + + The direction angle of the light source in the XY plane relative to the X-axis in the counter clock wise direction. The units are in degrees and must be between 0 and 360 degrees. + + +The type is FLOAT. + +The default value is 0.0f. + + + The direction angle of the light source in the YZ plane relative to the Y-axis in the counter clock wise direction. The units are in degrees and must be between 0 and 360 degrees. + + +The type is FLOAT. + +The default value is 0.0f. + + + The ratio of diffuse reflection to amount of incoming light. This property must be between 0 and 10,000 and is unitless. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction. The surface scale is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a D2D1_VECTOR_3F – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f}. + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y direction. This property maps to the dx and dy values in the Sobel gradient. This property is a D2D1_VECTOR_2F (Kernel Unit Length X, Kernel Unit Length Y) and is defined in (device-independent pixels (DIPs)/Kernel Unit). The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_DISTANTDIFFUSE_SCALE_MODE. + +The default value is D2D1_DISTANTDIFFUSE_SCALE_MODE_LINEAR. + + + + Specifies the paint type for an SVG fill or stroke. + Microsoft Docs: + + + + The fill or stroke is not rendered. + + + A solid color is rendered. + + + The current color is rendered. + + + A paint server, defined by another element in the SVG document, is used. + + + A paint server, defined by another element in the SVG document, is used. If the paint server reference is invalid, fall back to D2D1_SVG_PAINT_TYPE_NONE. + + + A paint server, defined by another element in the SVG document, is used. If the paint server reference is invalid, fall back to D2D1_SVG_PAINT_TYPE_COLOR. + + + A paint server, defined by another element in the SVG document, is used. If the paint server reference is invalid, fall back to D2D1_SVG_PAINT_TYPE_CURRENT_COLOR. + + + + Draws the provided image to the command sink. + Microsoft Docs: + The image to be drawn to the command sink. + This defines the offset in the destination space that the image will be rendered to. The entire logical extent of the image will be rendered to the corresponding destination. If not specified, the destination origin will be (0, 0). The top-left corner of the image will be mapped to the target offset. This will not necessarily be the origin. + The corresponding rectangle in the image space will be mapped to the provided origins when processing the image. + The interpolation mode to use to scale the image if necessary. + If specified, the composite mode that will be applied to the limits of the currently selected clip. + + + + + Specifies which gamma is used for interpolation. + Microsoft Docs: + + + + Interpolation is performed in the standard RGB (sRGB) gamma. + + + Interpolation is performed in the linear-gamma color space. + + + + Indicates whether the buffer precision is supported by the underlying Direct2D device. + Microsoft Docs: + The buffer precision to check. + + + + + Gets the number of the dashes in the array. + Microsoft Docs: + + + + + Identifiers for properties of the Tile effect. + Microsoft Docs: + + + + The region of the image to be tiled. This property is a D2D1_VECTOR_4F defined as: (left, top, right, bottom). The units are in DIPs. + + +The type is D2D1_VECTOR_4F. + +The default is {0.0f, 0.0f, 100.0f, 100.0f}. + + + + Represents the backing store required to render a layer. + Microsoft Docs: + + + + + Creates an effect for the specified class ID. + Microsoft Docs: + The class ID of the effect to create. See Built-in Effects for a list of effect IDs. + When this method returns, contains the address of a pointer to a new effect. + + + + + Creates a path geometry object representing the path data. + Microsoft Docs: + Fill mode for the path geometry object. + On completion, pathGeometry will contain a point to the created ID2D1PathGeometry1 object. + + + + + Connects a transform node inside the graph to the corresponding effect input of the encapsulating effect. + Microsoft Docs: + The effect input to which the transform node will be bound. + The node to which the connection will be made. + The node input that will be connected. + + + + + Specifies the color channel the Displacement map effectextracts the intensity from and uses it to spatially displace the image in the X or Y direction. + Microsoft Docs: + + + + The effect extracts the intensity output from the red channel. + + + The effect extracts the intensity output from the green channel. + + + The effect extracts the intensity output from the blue channel. + + + The effect extracts the intensity output from the alpha channel. + + + + Draws the specified glyphs. + Microsoft Docs: + The origin, in device-independent pixels, of the glyphs' baseline. + The glyphs to render. + The brush used to paint the specified glyphs. + A value that indicates how glyph metrics are used to measure text when it is formatted. The default value is DWRITE_MEASURING_MODE_NATURAL. + + + + + Returns the size, in device-dependent units (pixels), of the bitmap. + Microsoft Docs: + + + + + Sets whether the output of the specified transform is cached. + Microsoft Docs: + TRUE if the output should be cached; otherwise, FALSE. + + + + + Returns the world bounds of a given gradient mesh. + Microsoft Docs: + The gradient mesh whose world bounds will be calculated. + When this method returns, contains a pointer to the bounds of the gradient mesh, in device independent pixels (DIPs). + + + + + Identifiers for properties of the Scale effect. + Microsoft Docs: + + + + The scale amount in the X and Y direction as a ratio of the output size to the input size. + + +This property a D2D1_VECTOR_2F defined as: (X scale, Y scale). + The scale amounts are FLOAT, unitless, and must be positive or 0. + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The image scaling center point. This property is a D2D1_VECTOR_2F defined as: (point X, point Y). The units are in DIPs. + + +Use the center point property to scale around a point other than the upper-left corner. + +The type is D2D1_VECTOR_2F. + +The default value is {0.0f, 0.0f}. + + + The interpolation mode the effect uses to scale the image. There are 6 scale modes that range in quality and speed. + + +The type is D2D1_SCALE_INTERPOLATION_MODE. + +The default value is D2D1_SCALE_INTERPOLATION_MODE_LINEAR. + + + The mode used to calculate the border of the image, soft or hard. + + +The type is D2D1_BORDER_MODE. + +The default value is D2D1_BORDER_MODE_SOFT. + + + In the high quality cubic interpolation mode, the sharpness level of the scaling filter as a float between 0 and 1. The values are unitless. + You can use sharpness to adjust the quality of an image when you scale the image down. + + +The sharpness factor affects the shape of the kernel. The higher the sharpness factor, the smaller the kernel. + +
Note  This property affects only the high quality cubic interpolation mode.
+
 
+The type is FLOAT. + +The default value is 0.0f. + + + + Defines constants that specify a value for the D2D1_HDRTONEMAP_PROP_DISPLAY_MODE property of the HDR Tone Map effect. + Microsoft Docs: + + + + Specifies that the tone mapper algorithm be optimized for best appearance on a standard dynamic range (SDR) display. + + + Specifies that the tone mapper algorithm be optimized for best appearance on a high dynamic range (HDR) display. + + + + Retrieves the number of segments in the path geometry. + Microsoft Docs: + A pointer that receives the number of segments in the path geometry when this method returns. You must allocate storage for this parameter. + + + + + Describes whether a window is occluded. + Microsoft Docs: + + + + The window is not occluded. + + + The window is occluded. + + + + Indicates whether a segment should be stroked and whether the join between this segment and the previous one should be smooth. This enumeration allows a bitwise combination of its member values. + Microsoft Docs: + + + + The segment is joined as specified by the ID2D1StrokeStyle interface, and it is stroked. + + + The segment is not stroked. + + + The segment is always joined with the one preceding it using a round line join, regardless of which D2D1_LINE_JOINenumeration is specified by the ID2D1StrokeStyle interface. If this segment is the first segment and the figure is closed, a round line join is used to connect the closing segment with the first segment. If the figure is not closed, this setting has no effect on the first segment of the figure. If ID2D1SimplifiedGeometrySink::SetSegmentFlags is called just before ID2D1SimplifiedGeometrySink::EndFigure, the join between the closing segment and the last explicitly specified segment is affected. + + + + This interface performs all the same functions as the existing ID2D1CommandSink3 interface. It also enables access to the new primitive blend mode, MAX, through the SetPrimitiveBlend2 method. + Microsoft Docs: + + + + + Sets the compute shader to the given shader resource. The resource must be loaded before this call is made. + Microsoft Docs: + The GUID of the shader. + + + + + Specifies how a bitmap can be used. + Microsoft Docs: + + + + The bitmap is created with default properties. + + + The bitmap can be used as a device context target. + + + The bitmap cannot be used as an input. + + + The bitmap can be read from the CPU. + + + The bitmap works with ID2D1GdiInteropRenderTarget::GetDC. + +
Note  This flag is not available in Windows Store apps.
+
 
 + + + + Returns the input rectangles that are required to be supplied by the caller to produce the given output rectangle. + Microsoft Docs: + The image whose output is being rendered. + The portion of the output image whose inputs are being inspected. + A list of the inputs whos rectangles are being queried. + The input rectangles returned to the caller. + The number of inputs. + + + + + Specifies additional aspects of how a sprite batch is to be drawn, as part of a call to ID2D1DeviceContext3::DrawSpriteBatch. + Microsoft Docs: + + + + Default value. No special drawing configuration. This option yields the best drawing performance. + + + Interpolation of bitmap pixels will be clamped to the sprite’s source rectangle. + If the sub-images in your source bitmap have no pixels separating them, then you may see color bleeding when drawing them with D2D1_SPRITE_OPTIONS_NONE. + In that case, consider adding borders between them with your sprite-packing tool, or use this option. + Note that drawing sprites with this option enabled is slower than using D2D1_SPRITE_OPTIONS_NONE. + + + + Maps the provided data into user memory. + Microsoft Docs: + When this method returns, contains the address of a pointer to the available buffer. + The desired size of the buffer. + + + + + Specifies a value for the SVG stroke-linejoin property. + Microsoft Docs: + + + + The property is set to SVG's 'bevel' value. + + + The property is set to SVG's 'miter' value. Note that this is equivalent to D2D1_LINE_JOIN_MITER_OR_BEVEL, not D2D1_LINE_JOIN_MITER. + + + The property is set to SVG's 'round' value. + + + + Updates the specific resource texture inside the specific range or box using the supplied data. + Microsoft Docs: + The "left" extent of the updates if specified; if NULL, the entire texture is updated. + The "right" extent of the updates if specified; if NULL, the entire texture is updated. + The stride to advance through the input data, according to dimension. + The number of dimensions in the resource texture. This must match the number used to load the texture. + The data to be placed into the resource texture. + The size of the data buffer to be used to update the resource texture. + + + + + Allows a caller to control the output precision and channel-depth of the transform in which the render information is encapsulated. + Microsoft Docs: + The type of buffer that should be used as an output from this transform. + The number of channels that will be used on the output buffer. + + + + + Specifies the indices of the system properties present on the ID2D1Properties interface for an ID2D1Effect. + Microsoft Docs: + + + + The CLSID of the effect. + + + The name of the effect. + + + The author of the effect. + + + The category of the effect. + + + The description of the effect. + + + The names of the effect's inputs. + + + The output of the effect should be cached. + + + The buffer precision of the effect output. + + + The minimum number of inputs supported by the effect. + + + The maximum number of inputs supported by the effect. + + + + Returns the class IDs of the currently registered effects and global effects on this factory. + Microsoft Docs: + When this method returns, contains an array of effects. NULL if no effects are retrieved. + The capacity of the effects array. + When this method returns, contains the number of effects copied into effects. + When this method returns, contains the number of effects currently registered in the system. + + + + + Retrieves the color of the solid color brush. + Microsoft Docs: + + + + + Indicates the type of information provided by the Direct2D Debug Layer. + Microsoft Docs: + + + + Direct2D does not produce any debugging output. + + + Direct2D sends error messages to the debug layer. + + + Direct2D sends error messages and warnings to the debug layer. + + + Direct2D sends error messages, warnings, and additional diagnostic information that can help improve performance to the debug layer. + + + + Values for the D2D1_STRAIGHTEN_PROP_SCALE_MODE property of the Straighten effect. + Microsoft Docs: + + + + Indicates nearest neighbor interpolation should be used. + + + Indicates linear interpolation should be used. + + + Indicates cubic interpolation should be used. + + + Indicates multi-sample linear interpolation should be used. + + + Indicates anisotropic filtering should be used. + + + + Paints an area with a solid color. + Microsoft Docs: + + + + + Represents all SVG preserveAspectRatio settings. + Microsoft Docs: + + + + Sets the 'defer' portion of the preserveAspectRatio settings. This field only has an effect on an 'image' element that references another SVG document. As + this is not currently supported, the field has no impact on rendering. + + + Sets the align portion of the preserveAspectRatio settings. + + + Sets the meetOrSlice portion of the preserveAspectRatio settings. + + + + Gets the maximum size, in device-dependent units (pixels), of any one bitmap dimension supported by the render target. + Microsoft Docs: + + + + + Represents a Direct2D drawing resource. + Microsoft Docs: + + + + + Unmaps the vertex buffer. + Microsoft Docs: + + + + + Sets the priority of Direct2D rendering operations performed on any device context associated with the device. + Microsoft Docs: + The desired rendering priority for the device and associated contexts. + + + + + Represents a graph of transform nodes. + Microsoft Docs: + + + + + Retrieves the pixel format and alpha mode of the render target. + Microsoft Docs: + + + + + Creates a color context by loading it from the specified filename. The profile bytes are the contents of the file specified by filename. + Microsoft Docs: + The path to the file containing the profile bytes to initialize the color context with. + When this method returns, contains the address of a pointer to a new color context. + + + + + Describes the stroke that outlines a shape. + Microsoft Docs: + + + + The cap to use at the start of each open figure. + + + The cap to use at the end of each open figure. + + + The cap to use at the start and end of each dash. + + + The line join to use. + + + The limit beyond which miters are either clamped or converted to bevels. + + + The type of dash to use. + + + The location of the first dash, relative to the start of the figure. + + + The rule that determines what render target properties affect the nib of the stroke. + + + + Copies the gradient stops from the collection into an array of D2D1_GRADIENT_STOP structures. + Microsoft Docs: + A pointer to a one-dimensional array of D2D1_GRADIENT_STOP structures. When this method returns, the array contains copies of the collection's gradient stops. You must allocate the memory for this array. + A value indicating the number of gradient stops to copy. If the value is less than the number of gradient stops in the collection, the remaining gradient stops are omitted. If the value is larger than the number of gradient stops in the collection, the extra gradient stops are set to NULL. To obtain the number of gradient stops in the collection, use the GetGradientStopCount method. + + + + + Represents a device-dependent representation of a gradient mesh composed of patches. Use the ID2D1DeviceContext2::CreateGradientMesh method to create an instance of ID2D1GradientMesh. + Microsoft Docs: + + + + + Sets the interpolation mode for the brush. + Microsoft Docs: + The mode to use. + + + + + Represents a single continuous stroke of variable-width ink, as defined by a series of Bezier segments and widths. + Microsoft Docs: + + + + + Sets the extend mode in the y direction. + Microsoft Docs: + The extend mode in the y direction. + + + + + Retrieves the source geometry of this transformed geometry object. + Microsoft Docs: + When this method returns, contains a pointer to a pointer to the source geometry for this transformed geometry object. This parameter is passed uninitialized. + + + + + Identifiers for properties of the Gamma transfer effect. + Microsoft Docs: + + + + The amplitude of the gamma transfer function for the Red channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The exponent of the gamma transfer function for the Red channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The offset of the gamma transfer function for the Red channel. + + +The type is FLOAT. + +The default value is 0.0f. + + + If you set this to TRUE it does not apply the transfer function to the Red channel. An identity transfer function is used. + If you set this to FALSE it applies the gamma transfer function to the Red channel. + + +The type is BOOL. + +The default value is FALSE. + + + The amplitude of the gamma transfer function for the Green channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The exponent of the gamma transfer function for the Green channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The offset of the gamma transfer function for the Green channel. + + +The type is FLOAT. + +The default value is 0.0f. + + + If you set this to TRUE it does not apply the transfer function to the Green channel. An identity transfer function is used. + If you set this to FALSE it applies the gamma transfer function to the Green channel. + + +The type is BOOL. + +The default value is FALSE. + + + The amplitude of the gamma transfer function for the Blue channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The exponent of the gamma transfer function for the Blue channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The offset of the gamma transfer function for the Blue channel. + + +The type is FLOAT. + +The default value is 0.0f. + + + If you set this to TRUE it does not apply the transfer function to the Blue channel. An identity transfer function is used. + If you set this to FALSE it applies the gamma transfer function to the Blue channel. + + +The type is BOOL. + +The default value is FALSE. + + + The amplitude of the gamma transfer function for the Alpha channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The exponent of the gamma transfer function for the Alpha channel. + + +The type is FLOAT. + +The default value is 1.0f. + + + The offset of the gamma transfer function for the Alpha channel. + + +The type is FLOAT. + +The default value is 0.0f. + + + If you set this to TRUE it does not apply the transfer function to the Alpha channel. An identity transfer function is used. + If you set this to FALSE it applies the gamma transfer function to the Alpha channel. + + +The type is BOOL. + +The default value is FALSE. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. + The effect clamps the values before it premultiplies the alpha. + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + + +The type is BOOL. + +The default value is FALSE. + + + + Gets the output image from the effect. + Microsoft Docs: + When this method returns, contains the address of a pointer to the output image for the effect. + + + + + Represents an SVG document. + Microsoft Docs: + + + + + Opens the mesh for population. + Microsoft Docs: + When this method returns, contains a pointer to a pointer to an ID2D1TessellationSink that is used to populate the mesh. This parameter is passed uninitialized. + + + + + Retrieves an image of the SVG glyph from the color glyph cache. + Microsoft Docs: + Origin of the glyph. + Reference to a font face which contains font face type, appropriate file references, face identification data and various font data such as metrics, names and glyph outlines. + The specified font size affects the output + glyphTransform, causing it to properly scale the glyph. + Index of the glyph to retrieve. + If true, specifies that glyphs are rotated 90 degrees to the left and vertical metrics are used. Vertical writing is achieved by specifying isSideways as true and rotating the entire run 90 degrees to the right via a rotate transform. + The transform to apply to the image. + Describes how the area is painted. + The values for context-fill, context-stroke, and context-value that are used when rendering SVG glyphs. + The index used to select a color palette within a color font. + Note that this not the same as the paletteIndex in the DWRITE_COLOR_GLYPH_RUN struct, which is not relevant for SVG glyphs. + Output transform, which transforms from the glyph's space to the same output space as the worldTransform. + This includes the input glyphOrigin, the glyph's offset from the glyphOrigin, and any other required transformations. + On completion, contains the retrieved glyph image. + + + + + Creates and returns a bounds adjustment transform. + Microsoft Docs: + The initial output rectangle for the bounds adjustment transform. + The returned bounds adjustment transform. + + + + + Creates a new device context with no initially assigned target. + Microsoft Docs: + Options for creating the device context. + The created device context. + + + + + Represents a sequence of commands that can be recorded and played back. + Microsoft Docs: + + + + + Represents the set of transforms implemented by the effect-rendering system, which provides fixed-functionality. + Microsoft Docs: + + + + + Specifies the indices of the system sub-properties that may be present in any property. + Microsoft Docs: + + + + The name for the parent property. + + + A Boolean indicating whether the parent property is writeable. + + + The minimum value that can be set to the parent property. + + + The maximum value that can be set to the parent property. + + + The default value of the parent property. + + + An array of name/index pairs that indicate the possible values that can be set to the parent property. + + + An index sub-property used by the elements of the D2D1_SUBPROPERTY_FIELDS array. + + + + Contains the content bounds, mask information, opacity settings, and other options for a layer resource. + Microsoft Docs: + + + + The content bounds of the layer. Content outside these bounds is not guaranteed to render. + + + The geometric mask specifies the area of the layer that is composited into the render target. + + + A value that specifies the antialiasing mode for the geometricMask. + + + A value that specifies the transform that is applied to the geometric mask when composing the layer. + + + An opacity value that is applied uniformly to all resources in the layer when compositing to the target. + + + A brush that is used to modify the opacity of the layer. The brush +is mapped to the layer, and the alpha channel of each mapped brush pixel is multiplied against the corresponding layer pixel. + + + A value that specifies whether the layer intends to render text with ClearType antialiasing. + + + + This finds the given vertex buffer if it has already been created with ID2D1EffectContext::CreateVertexBuffer with the same GUID. + Microsoft Docs: + The unique id that identifies the vertex buffer. + The returned vertex buffer that can be used as a resource in a Direct2D effect. + + + + + The creation properties for a ID2D1PrintControl object. + Microsoft Docs: + + + + The mode to use for subsetting fonts for printing, defaults to D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT. + + + DPI for rasterization of all unsupported Direct2D commands or options, defaults to 150.0. + + + Color space for vector graphics, defaults to D2D1_COLOR_SPACE_SRGB. + + + + Defines the type of SVG string attribute to set or get. + Microsoft Docs: + + + + The attribute is a string in the same form as it would appear in the SVG XML. + Note that when getting values of this type, the value returned may not exactly match the value that was set. Instead, the output value is a normalized version + of the value. For example, an input color of 'red' may be output as '#FF0000'. + + + The attribute is an element ID. + + + + Creates a new ID2D1DeviceContext2 from a Direct2D device. + Microsoft Docs: + The options to be applied to the created device context. + When this method returns, contains the address of a pointer to the new device context. + + + + + Creates an element from a tag name. The element is appended to the list of children. + Microsoft Docs: + The tag name of the new child. An empty string is interpreted to be a text content element. + The new child element. + + + + + Specifies additional features supportable by a compatible render target when it is created. This enumeration allows a bitwise combination of its member values. + Microsoft Docs: + + + + The render target supports no additional features. + + + The render target supports interoperability with the Windows Graphics Device Interface (GDI). + + + + Indicates that drawing with the device context retrieved using the GetDC method is finished. + Microsoft Docs: + The modified region of the device context, or NULL to specify the entire render target. + + + + + Indicates a mesh to be filled by the command sink. + Microsoft Docs: + The mesh object to be filled. + The brush with which to fill the mesh. + + + + + Represents filtering modes that a transform may select to use on input textures. + Microsoft Docs: + + + + Use point sampling for minification, magnification, and mip-level sampling. + + + Use point sampling for minification and magnification; use linear interpolation for mip-level sampling. + + + Use point sampling for minification; use linear interpolation for magnification; use point sampling for mip-level sampling. + + + Use point sampling for minification; use linear interpolation for magnification and mip-level sampling. + + + Use linear interpolation for minification; use point sampling for magnification and mip-level sampling. + + + Use linear interpolation for minification; use point sampling for magnification; use linear interpolation for mip-level sampling. + + + Use linear interpolation for minification and magnification; use point sampling for mip-level sampling. + + + Use linear interpolation for minification, magnification, and mip-level sampling. + + + Use anisotropic interpolation for minification, magnification, and mip-level sampling. + + + + Sets the pre-transform nib shape for this style. + Microsoft Docs: + The pre-transform nib shape to use in this style. + + + + + This indicates that a portion of an effect's input is invalid. This method can be called many times. + Microsoft Docs: + The effect to invalidate. + The input index. + The rect to invalidate. + + + + + Returns whether the Direct2D factory was created with the D2D1_FACTORY_TYPE_MULTI_THREADED flag. + Microsoft Docs: + + + + + Creates a transform that extends its input infinitely in every direction based on the passed in extend mode. + Microsoft Docs: + The extend mode in the X-axis direction. + The extend mode in the Y-axis direction. + The returned transform. + + + + + Tries to invert the specified matrix. + Microsoft Docs: + The matrix to invert. + + + + + Specifies how the intersecting areas of geometries or figures are combined to form the area of the composite geometry. + Microsoft Docs: + + + + Determines whether a point is in the fill region by drawing a ray from that point to infinity in any direction, and then counting the number of path segments within the given shape that the ray crosses. If this number is odd, the point is in the fill region; if even, the point is outside the fill region. + + + Determines whether a point is in the fill region of the path by drawing a ray from that point to infinity in any direction, and then examining the places where a segment of the shape crosses the ray. Starting with a count of zero, add one each time a segment crosses the ray from left to right and subtract one each time a path segment crosses the ray from right to left, as long as left and right are seen from the perspective of the ray. After counting the crossings, if the result is zero, then the point is outside the path. Otherwise, it is inside the path. + + + + Forces the factory to refresh any system defaults that it might have changed since factory creation. + Microsoft Docs: + + + + + Represents a point, radius pair that makes up part of a D2D1_INK_BEZIER_SEGMENT. + Microsoft Docs: + + + + The x-coordinate of the point. + + + The y-coordinate of the point. + + + The radius of this point. Corresponds to the width of the ink stroke at this point in the stroke. + + + + Restores access to resources that were previously offered by calling OfferResources. + Microsoft Docs: + Returns with TRUE if the corresponding resource’s content was discarded and is now undefined, or FALSE if the corresponding resource’s old content is still intact. + The caller can pass in NULL, if the caller intends to fill the resources with new content regardless of whether the old content was discarded. + + + + + Gets the transform applied to this brush. + Microsoft Docs: + The transform applied to this brush. + + + + + Specifies how a device context is initialized for GDI rendering when it is retrieved from the render target. + Microsoft Docs: + + + + The current contents of the render target are copied to the device context when it is initialized. + + + The device context is cleared to transparent black when it is initialized. + + + + Retrieves the current rendering priority of the device. + Microsoft Docs: + + + + + Specifies options that can be applied when a layer resource is applied to create a layer. + Microsoft Docs: + + + + The text in this layer does not use ClearType antialiasing. + + + The layer renders correctly for ClearType text. If the render target is set to ClearType, the layer continues to render ClearType. If the render target is 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. + + + + Draw a metafile to the device context. + Microsoft Docs: + The metafile to draw. + The offset from the upper left corner of the render target. + + + + + Represents a complex shape that may be composed of arcs, curves, and lines. + Microsoft Docs: + + + + + Identifiers for properties of the Opacity metadata effect. + Microsoft Docs: + + + + The portion of the source image that is opaque. The default is the entire input image. + + +The type is D2D1_VECTOR_4F. + +The default is {-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX}. + + + + Specifies the offset of the gradient origin relative to the gradient ellipse's center. + Microsoft Docs: + The offset of the gradient origin from the center of the gradient ellipse. + + + + + Provides an estimated hint of shader execution cost to D2D. + Microsoft Docs: + An approximate instruction count of the associated shader. + + + + + Create a mesh that uses triangles to describe a shape. + Microsoft Docs: + When this method returns, contains a pointer to a pointer to the new mesh. + + + + + Gets the extend mode in the y direction. + Microsoft Docs: + + + + + Identifiers for properties of the Crop effect. + Microsoft Docs: + + + + The region to be cropped specified as a vector in the form (left, top, width, height). Units are in DIPs. + + +
Note  The rectangle will be truncated if it overlaps the edge boundaries of the input image.
+
 
+Type is D2D1_VECTOR_4F + + +Default value is {-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX} + + + Indicates how the effect handles the crop rectangle falling on fractional pixel coordinates. + + +Type is D2D1_BORDER_MODE. + +Default value is D2D1_BORDER_MODE_SOFT. + + + + Ends drawing operations on the render target and indicates the current error state and associated tags. + Microsoft Docs: + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + + + + + Specifies the threading mode used while simultaneously creating the device, factory, and device context. + Microsoft Docs: + + + + Resources may only be invoked serially. Device context state is not protected from multi-threaded access. + + + Resources may be invoked from multiple threads. Resources use interlocked reference counting and their state is protected. + + + + Identifiers for properties of the Point-diffuse lighting effect. + Microsoft Docs: + + + + The light position of the point light source. The property is a D2D1_VECTOR_3F defined as (x, y, z). The units are in device-independent pixels (DIPs) and are unbounded. + + +The type is D2D1_VECTOR_3F. + +The default value is {0.0f, 0.0f, 0.0f}. + + + The ratio of diffuse reflection to amount of incoming light. This property must be between 0 and 10,000 and is unitless. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction. The surface scale is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a Vector 3 – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f}. + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y direction. This property maps to the dx and dy values in the Sobel gradient. + This property is a D2D1_VECTOR_2F (Kernel Unit Length X, Kernel Unit Length Y) and is defined in (DIPs/Kernel Unit). + The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_POINTDIFFUSE_SCALE_MODE. + +The default value is D2D1_POINTDIFFUSE_SCALE_MODE_LINEAR. + + + + Draws a bitmap to the render target. + Microsoft Docs: + The bitmap to draw. + The destination rectangle. The default is the size of the bitmap and the location is the upper left corner of the render target. + The opacity of the bitmap. + The interpolation mode to use. + An optional source rectangle. + An optional perspective transform. + + + + + Describes a point on a path geometry. + Microsoft Docs: + + + + The end point after walking the path. + + + A unit vector indicating the tangent point. + + + The index of the segment on which point resides. This index is global to the entire path, not just to a particular figure. + + + The index of the figure on which point resides. + + + The length of the section of the path stretching from the start of the path to the start of endSegment. + + + + Identifiers for properties of the Posterize effect. + Microsoft Docs: + + + + The D2D1_POSTERIZE_PROP_RED_VALUE_COUNT property is an integer value specifying how many evenly spaced steps to divide the red channel range of 0.0 to 1.0 into. + For example, a value of 4 generates a table with 4 steps, [0.0, 0.33, 0.67, 1.0]. The allowed range for this property is 2 to 16. The default value is 4. + + + The D2D1_POSTERIZE_PROP_GREEN_VALUE_COUNT property is an integer value specifying how many evenly spaced steps to divide the green channel range of 0.0 to 1.0 into. + For example, a value of 4 generates a table with 4 steps, [0.0, 0.33, 0.67, 1.0]. The allowed range for this property is 2 to 16. The default value is 4. + + + The D2D1_POSTERIZE_PROP_BLUE_VALUE_COUNT property is an integer value specifying how many evenly spaced steps to divide the blue channel range of 0.0 to 1.0 into. + For example, a value of 4 generates a table with 4 steps, [0.0, 0.33, 0.67, 1.0]. The allowed range for this property is 2 to 16. The default value is 4. + + + + Clears all of the rendering resources used by Direct2D. + Microsoft Docs: + Discards only resources that haven't been used for greater than the specified time in milliseconds. The default is 0 milliseconds. + + + + + Sets the given input effect by index. + Microsoft Docs: + The index of the input to set. + The input effect to set. + Whether to invalidate the graph at the location of the effect input + + + + + Creates a line segment between the current point and the specified end point and adds it to the geometry sink. + Microsoft Docs: + The end point of the line to draw. + + + + + Gets the interpolation method used when the brush bitmap is scaled or rotated. + Microsoft Docs: + + + + + Retrieves the ending coordinates of the linear gradient. + Microsoft Docs: + + + + + Identifiers for properties of the Spot-specular lighting effect. + Microsoft Docs: + + + + The light position of the point light source. The property is a D2D1_VECTOR_3F defined as (x, y, z). + The units are in device-independent pixels (DIPs) and are unbounded. + + +The type is D2D1_VECTOR_3F. + +The default value is {0.0f, 0.0f, 0.0f}. + + + Where the spot light is focused. The property is exposed as a D2D1_VECTOR_3F with – (x, y, z). + The units are in DIPs and the values are unbounded. + + +The type is D2D1_VECTOR_3F. + +The default value is {0.0f, 0.0f, 0.0f}. + + + The focus of the spot light. This property is unitless and is defined between 0 and 200. + + +The type is FLOAT. + +The default value is 1.0f. + + + The cone angle that restricts the region where the light is projected. No light is projected outside the cone. + The limiting cone angle is the angle between the spot light axis (the axis between the LightPosition and PointsAt properties) and the spot light cone. + This property is defined in degrees and must be between 0 to 90 degrees. + + +The type is FLOAT. + +The default value is 90.0f. + + + The exponent for the specular term in the Phong lighting equation. A larger value corresponds to a more reflective surface. This value is unitless and must be between 1.0 and 128. + + +The type is FLOAT. + +The default value is 1.0f. + + + The ratio of specular reflection to the incoming light. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction for generating a height map. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a Vector 3 – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f}. + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y direction. This property maps to the dx and dy values in the Sobel gradient. + This property is a D2D1_VECTOR_2F (Kernel Unit Length X, Kernel Unit Length Y) and is defined in (DIPs/Kernel Unit). + The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_SPOTSPECULAR_SCALE_MODE. + +The default value is D2D1_SPOTSPECULAR_SCALE_MODE_LINEAR. + + + + Represents a set of run-time bindable and discoverable properties that allow a data-driven application to modify the state of a Direct2D effect. + Microsoft Docs: + + + + + Indicates more detailed text rendering parameters. + Microsoft Docs: + The parameters to use for text rendering. + + + + + Returns a boolean indicating wether this element represents text content. + Microsoft Docs: + + + + + Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the ID2D1Device4 interface. It also enables the creation of ID2D1DeviceContext5 objects. + Microsoft Docs: + + + + + Describes the sequence of dashes and gaps in a stroke. + Microsoft Docs: + + + + A solid line with no breaks. + + + A dash followed by a gap of equal length. The dash and the gap are each twice as long as the stroke thickness. + +The equivalent dash array for D2D1_DASH_STYLE_DASH is {2, 2}. + + + A dot followed by a longer gap. + +The equivalent dash array for D2D1_DASH_STYLE_DOT is {0, 2}. + + + A dash, followed by a gap, followed by a dot, followed by another gap. + +The equivalent dash array for D2D1_DASH_STYLE_DASH_DOT is {2, 2, 0, 2}. + + + A dash, followed by a gap, followed by a dot, followed by another gap, followed by another dot, followed by another gap. + +The equivalent dash array for D2D1_DASH_STYLE_DASH_DOT_DOT is {2, 2, 0, 2, 0, 2}. + + + The dash pattern is specified by an array of floating-point values. + + + + Allows the application to change the number of inputs to an effect. + Microsoft Docs: + The number of inputs to the effect. + + + + + Defines constants that identify the top level properties of the White Level Adjustment effect. + Microsoft Docs: + + + + Identifies the InputWhiteLevel property of the effect. The property is of type FLOAT, and is specified in nits. + + + Identifies the OutputWhiteLevel property of the effect. The property is of type FLOAT, and is specified in nits. + + + + Identifiers for properties of the Chroma-key effect. + Microsoft Docs: + + + + The D2D1_CHROMAKEY_PROP_COLOR property is a vector4 value indicating the color that should be converted to alpha. The default color is black. + + + The D2D1_CHROMAKEY_PROP_TOLERANCE property is a float value indicating the tolerance for matching the color specified in the D2D1_CHROMAKEY_PROP_COLOR property. + The allowed range is 0.0 to 1.0. The default value is 0.1. + + + The D2D1_CHROMAKEY_PROP_INVERT_ALPHA property is a boolean value indicating whether the alpha values should be inverted. The default value if False. + + + The D2D1_CHROMAKEY_PROP_FEATHER property is a boolean value whether the edges of the output should be softened in the alpha channel. + When set to False, the alpha output by the effect is 1-bit: either fully opaque or fully transparent. Setting to True results in a softening of edges in the alpha channel of the Chroma Key output. + The default value is False. + + + + Copies the dash pattern to the specified array. + Microsoft Docs: + A pointer to an array that will receive the dash pattern. The array must be able to contain at least as many elements as specified by dashesCount. You must allocate storage for this array. + The number of dashes to copy. If this value is less than the number of dashes in the stroke style's dashes array, the returned dashes are truncated to dashesCount. If this value is greater than the number of dashes in the stroke style's dashes array, the extra dashes are set to 0.0f. To obtain the actual number of dashes in the stroke style's dashes array, use the GetDashesCount method. + + + + + Retrieves the y-radius of the gradient ellipse. + Microsoft Docs: + + + + + Returns the length of a 3 dimensional vector. + Microsoft Docs: + The x value of the vector. + The y value of the vector. + The z value of the vector. + + + + + Identifiers for properties of the Sharpen effect. + Microsoft Docs: + + + + The D2D1_SHARPEN_PROP_SHARPNESS property is a float value indicating how much to sharpen the input image. The allowed range is 0.0 to 10.0. The default value is 0.0. + + + The D2D1_SHARPEN_PROP_THRESHOLD property is a float value. The allowed range is 0.0 to 1.0. The default value is 0.0. + + + + Identifiers for properties of the Turbulence effect. + Microsoft Docs: + + + + The coordinates where the turbulence output is generated. + + +The algorithm used to generate the Perlin noise is position dependent, so a different offset results in a different output. + This property is not bounded and the units are specified in DIPs. + + +
Note  The offset does not have the same effect as a translation because the noise function output is infinite and the function will wrap around the tile.
+
 
+The type is D2D1_VECTOR_2F. + + +The default value is {0.0f, 0.0f}. + + + The base frequencies in the X and Y direction. This property is a float and must be greater than 0. The units are specified in 1/DIPs. + + +A value of 1 (1/DIPs) for the base frequency results in the Perlin noise completing an entire cycle between two pixels. The ease interpolation for these pixels results in completely random pixels, since there is no correlation between the pixels. + +A value of 0.1(1/DIPs) for the base frequency, the Perlin noise function repeats every 10 DIPs. This results in correlation between pixels and the typical turbulence effect is visible. + +The type is D2D1_VECTOR_2F. + + +The default value is {0.01f, 0.01f}. + + + The number of octaves for the noise function. This property is a UINT32 and must be greater than 0. + + +The type is UINT32. + +The default value is 1. + + + The seed for the pseudo random generator. This property is unbounded. + + +The type is UINT32. + +The default value is 0. + + + The turbulence noise mode. This property can be either fractal sum or turbulence. Indicates whether to generate a bitmap based on Fractal Noise or the Turbulence function. + + +The type is D2D1_TURBULENCE_NOISE. + + +The default value is D2D1_TURBULENCE_NOISE_FRACTAL_SUM. + + + Turns stitching on or off. The base frequency is adjusted so that output bitmap can be stitched. This is useful if you want to tile multiple copies of the turbulence effect output. + + +True – The output bitmap can be tiled (using the tile effect) without the appearance of seams. The base frequency is adjusted so that output bitmap can be stitched. + +False – The base frequency is not adjusted, so seams may appear between tiles if the bitmap is tiled. + +The type is BOOL. + +The default value is FALSE. + + + + Contains the three vertices that describe a triangle. + Microsoft Docs: + + + + The first vertex of a triangle. + + + The second vertex of a triangle. + + + The third vertex of a triangle. + + + + Identifiers for properties of the Vignette effect. + Microsoft Docs: + + + + The D2D1_VIGNETTE_PROP_COLOR property is an RGB tripplet that specifies the color to fade the image's edges to. The default color is black. + + + The D2D1_VIGNETTE_PROP_TRANSITION_SIZE property is a float value that specifies the size of the vignette region as a percentage of the full image region. + A size of 0 means the unfaded region is the entire image, while a size of 1 means the faded region is the entire source image. + The allowed range is 0.0 to 1.0. The default value is 0.1. + + + The D2D1_VIGNETTE_PROP_STRENGTH property is a float value that specifies how much the vignette color bleeds in for a given transition size. + The allowed range is 0.0 to 1.0. The default value is 0.5. + + + + Specifies the units for an SVG length. + Microsoft Docs: + + + + The length is unitless. + + + The length is a percentage value. + + + + Describes how a render target behaves when it presents its content. This enumeration allows a bitwise combination of its member values. + Microsoft Docs: + + + + The render target waits until the display refreshes to present and discards the frame upon presenting. + + + The render target does not discard the frame upon presenting. + + + The render target does not wait until the display refreshes to present. + + + + Indicates the new default antialiasing mode for text. + Microsoft Docs: + The antialiasing mode for the text. + + + + + Creates a device-dependent representation of the stroke of a geometry that can be subsequently rendered. + Microsoft Docs: + The geometry to realize. + The flattening tolerance to use when converting Beziers to line segments. This parameter shares the same units as the coordinates of the geometry. + The width of the stroke. This parameter shares the same units as the coordinates of the geometry. + The stroke style (optional). + When this method returns, contains the address of a pointer to a new geometry realization object. + + + + + Renders the given ink object using the given brush and ink style. + Microsoft Docs: + The ink object to be rendered. + The brush with which to render the ink object. + The ink style to use when rendering the ink object. + + + + + Represents a composite geometry, composed of other ID2D1Geometry objects. + Microsoft Docs: + + + + + Defines the general pen tip shape and the transform used in an ID2D1InkStyle object. + Microsoft Docs: + + + + The pre-transform shape of the nib (pen tip) used to draw a given ink object. + + + The transform applied to the nib. Note that the translation components of the transform matrix are ignored for the purposes of rendering. + + + + Indentifiers for properties of the RGB to Hue effect. + Microsoft Docs: + + + + The D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE property is an enumeration value which indicates the color space to convert to. + The default value for the property is D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE. + See the D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE enumeration for more information. + + + + Retrieves the type of joint used at the vertices of a shape's outline. + Microsoft Docs: + + + + + Represents a tensor patch with 16 control points, 4 corner colors, and boundary flags. An ID2D1GradientMesh is made up of 1 or more gradient mesh patches. Use the GradientMeshPatch function or the GradientMeshPatchFromCoonsPatch function to create one. + Microsoft Docs: + + + + The coordinate-space location of the control point in column 0 and row 0 of the tensor grid. + + + The coordinate-space location of the control point in column 0 and row 1 of the tensor grid. + + + The coordinate-space location of the control point in column 0 and row 2 of the tensor grid. + + + The coordinate-space location of the control point in column 0 and row 3 of the tensor grid. + + + The coordinate-space location of the control point in column 1 and row 0 of the tensor grid. + + + The coordinate-space location of the control point in column 1 and row 1 of the tensor grid. + + + The coordinate-space location of the control point in column 1 and row 2 of the tensor grid. + + + The coordinate-space location of the control point in column 1 and row 3 of the tensor grid. + + + The coordinate-space location of the control point in column 2 and row 0 of the tensor grid. + + + The coordinate-space location of the control point in column 2 and row 1 of the tensor grid. + + + The coordinate-space location of the control point in column 2 and row 2 of the tensor grid. + + + The coordinate-space location of the control point in column 2 and row 3 of the tensor grid. + + + The coordinate-space location of the control point in column 3 and row 0 of the tensor grid. + + + The coordinate-space location of the control point in column 3 and row 1 of the tensor grid. + + + The coordinate-space location of the control point in column 3 and row 2 of the tensor grid. + + + The coordinate-space location of the control point in column 3 and row 3 of the tensor grid. + + + The color associated with the control point in column 0 and row 0 of the tensor grid. + + + The color associated with the control point in column 0 and row 3 of the tensor grid. + + + The color associated with the control point in column 3 and row 0 of the tensor grid. + + + The color associated with the control point in column 3 and row 3 of the tensor grid. + + + Specifies how to render the top edge of the mesh. + + + Specifies how to render the left edge of the mesh. + + + Specifies how to render the bottom edge of the mesh. + + + Specifies how to render the right edge of the mesh. + + + + Gets the tag name. + Microsoft Docs: + The tag name. + Length of the value in the name argument. + + + + + Retrieves the color context type. + Microsoft Docs: + + + + + Sets the dots per inch (DPI) of the render target. + Microsoft Docs: + A value greater than or equal to zero that specifies the horizontal DPI of the render target. + A value greater than or equal to zero that specifies the vertical DPI of the render target. + + + + + Gets the previous sibling of the referenceChild element. + Microsoft Docs: + The referenceChild must be an immediate child of this element. + The output previousChild element will be non-null if the referenceChild has a previous sibling. If the referenceChild is the first child, the output is null. + + + + + Sets the input rectangles for this rendering pass into the transform. + Microsoft Docs: + The index of the input rectangle. + The invalid input rectangle. + The output rectangle to which the input rectangle must be mapped. + + + + + Describes flags that influence how the renderer interacts with a custom vertex shader. + Microsoft Docs: + + + + There were no changes. + + + The properties of the effect changed. + + + The context state changed. + + + The effect’s transform graph has changed. This happens only when an effect supports a variable input count. + + + + Registers an effect within the factory instance with the property XML specified as a string. + Microsoft Docs: + The identifier of the effect to be registered. + A list of the effect properties, types, and metadata. + An array of properties and methods. + +This binds a property by name to a particular method implemented by the effect author to handle the property. + The name must be found in the corresponding propertyXml. + The number of bindings in the binding array. + The static factory that is used to create the corresponding effect. + + + + + Contains the content bounds, mask information, opacity settings, and other options for a layer resource. + Microsoft Docs: + + + + The content bounds of the layer. Content outside these bounds is not guaranteed to render. + + + The geometric mask specifies the area of the layer that is composited into the render target. + + + A value that specifies the antialiasing mode for the geometricMask. + + + A value that specifies the transform that is applied to the geometric mask when composing the layer. + + + An opacity value that is applied uniformly to all resources in the layer when compositing to the target. + + + A brush that is used to modify the opacity of the layer. The brush +is mapped to the layer, and the alpha channel of each mapped brush pixel is multiplied against the corresponding layer pixel. + + + Additional options for the layer creation. + + + + Unmaps the bitmap from memory. + Microsoft Docs: + + + + + Creates an ID2D1Device3 object. + Microsoft Docs: + The IDXGIDevice object used when creating the ID2D1Device3. + The requested ID2D1Device3 object. + + + + + Gets the D2D1_ELLIPSE structure that describes this ellipse geometry. + Microsoft Docs: + When this method returns, contains the D2D1_ELLIPSE that describes the size and position of the ellipse. You must allocate storage for this parameter. + + + + + Gets the offset currently in the offset transform. + Microsoft Docs: + + + + + Copies the contents of the path geometry to the specified ID2D1GeometrySink. + Microsoft Docs: + The sink to which the path geometry's contents are copied. Modifying this sink does not change the contents of this path geometry. + + + + + Creates a new Direct2D device from the given IDXGIDevice. + Microsoft Docs: + The IDXGIDevice to create the Direct2D device from. + The created device. + + + + + Interface describing an SVG fill or stroke value. + Microsoft Docs: + + + + + This tests to see if the given shader is loaded. + Microsoft Docs: + The unique id that identifies the shader. + + + + + Removes an axis-aligned clip from the layer and clip stack. + Microsoft Docs: + + + + + Values for the D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE property of the Hue to RGB effect. + Microsoft Docs: + + + + The effect converts from Hue Saturation Value (HSV) to RGB. + + + The effect converts from Hue Saturation Lightness (HSL) to RGB. + + + + Gets the color space of the input colors as well as the space in which gradient stops are interpolated. + Microsoft Docs: + + + + + Identifiers for the properties of the Brightness effect. + Microsoft Docs: + + + + The upper portion of the brightness transfer curve. The white point adjusts the appearance of the brighter portions of the image. + This property is for both the x value and the y value, in that order. Each of the values of this property are between 0 and 1, inclusive. + + +The type is D2D1_VECTOR_2F. + +The default value is (1.0f, 1.0f). + + + The lower portion of the brightness transfer curve. The black point adjusts the appearance of the darker portions of the image. + This property is for both the x value and the y value, in that order. Each of the values of this property are between 0 and 1, inclusive. + + +The type is D2D1_VECTOR_2F. + +The default value is (0.0f, 0.0f). + + + + Removes the given number of segments from the end of this ink object. + Microsoft Docs: + The number of segments to be removed from the end of this ink object. Note that segmentsCount must be less or equal to the number of segments in the ink object. + + + + + Describes the pixel format and dpi of a bitmap. + Microsoft Docs: + + + + The bitmap's pixel format and alpha mode. + + + The horizontal dpi of the bitmap. + + + The vertical dpi of the bitmap. + + + + The interpolation mode the Convolve matrix effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor mode. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Contains the gradient origin offset and the size and position of the gradient ellipse for an ID2D1RadialGradientBrush. + Microsoft Docs: + + + + In the brush's coordinate space, the center of the gradient ellipse. + + + In the brush's coordinate space, the offset of the gradient origin relative to the gradient ellipse's center. + + + In the brush's coordinate space, the x-radius of the gradient ellipse. + + + In the brush's coordinate space, the y-radius of the gradient ellipse. + + + + Paints an area with a radial gradient. + Microsoft Docs: + + + + + Describes how a render target is remoted and whether it should be GDI-compatible. This enumeration allows a bitwise combination of its member values. + Microsoft Docs: + + + + The render target attempts to use Direct3D command-stream remoting and uses bitmap remoting if stream remoting fails. The render target is not GDI-compatible. + + + The render target renders content locally and sends it to the terminal services client as a bitmap. + + + The render target can be used efficiently with GDI. + + + + Specifies how to render gradient mesh edges. + Microsoft Docs: + + + + Render this patch edge aliased. Use this value for the internal edges of your gradient mesh. + + + Render this patch edge antialiased. Use this value for the external (boundary) edges of your mesh. + + + Render this patch edge aliased and also slightly inflated. Use this for the internal edges of your gradient mesh when there could be t-junctions among patches. + Inflating the internal edges mitigates seams that can appear along those junctions. + + + + Creates a new Direct2D device context associated with a DXGI surface. + Microsoft Docs: + The DXGI surface the Direct2D device context is associated with. + The properties to apply to the Direct2D device context. + When this function returns, contains the address of a pointer to a Direct2D device context. + + + + + Returns the number of patches that make up this gradient mesh. + Microsoft Docs: + + + + + Establishes or changes the constant buffer data for this transform. + Microsoft Docs: + The data applied to the constant buffer. + The number of bytes of data in the constant buffer. + + + + + Values for the D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE property of the RGB to Hue effect. + Microsoft Docs: + + + + The effect converts from RGB to Hue Saturation Value (HSV). + + + The effect converts from RGB to Hue Saturation Lightness (HSL). + + + + Instructs the effect-rendering system to offset an input bitmap without inserting a rendering pass. + Microsoft Docs: + + + + + Specifies the y-radius of the gradient ellipse, in the brush's coordinate space. + Microsoft Docs: + The y-radius of the gradient ellipse. This value is in the brush's coordinate space. + + + + + Sets the degree of opacity of this brush. + Microsoft Docs: + A value between zero and 1 that indicates the opacity of the brush. This value is a constant multiplier that linearly scales the alpha value of all pixels filled by the brush. The opacity values are clamped in the range 0–1 before they are multipled together. + + + + + Retrieves the geometry sink that is used to populate the path geometry with figures and segments. + Microsoft Docs: + When this method returns, geometrySink contains the address of a pointer to the geometry sink that is used to populate the path geometry with figures and segments. This parameter is passed uninitialized. + + + + + The interpolation mode the Point-diffuse lighting effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Initiates drawing on this render target. + Microsoft Docs: + + + + + Gets the color space of the color context. + Microsoft Docs: + + + + + Retrieves the number of sprites in this sprite batch. + Microsoft Docs: + + + + + Retrieves the ID2D1GradientStopCollection associated with this radial gradient brush object. + Microsoft Docs: + The ID2D1GradientStopCollection object associated with this linear gradient brush object. This parameter is passed uninitialized. + + + + + Specifies the blend operation on two color sources. + Microsoft Docs: + + + + Add source 1 and source 2. + + + Subtract source 1 from source 2. + + + Subtract source 2 from source 1. + + + Find the minimum of source 1 and source 2. + + + Find the maximum of source 1 and source 2. + + + A value guaranteed to be a DWORD. + + + + Represents the drawing state of a render target:\_the antialiasing mode, transform, tags, and text-rendering options. + Microsoft Docs: + + + + + Returns the tangent of an angle. + Microsoft Docs: + The angle to calculate the tangent for. + + + + + Sets the extend mode in the x direction. + Microsoft Docs: + The extend mode in the x direction. + + + + + Gets the index corresponding to the given property name. + Microsoft Docs: + The name of the property to retrieve. + + + + + Gets the element id which acts as the paint server. This id is used if the paint type is D2D1_SVG_PAINT_TYPE_URI. + Microsoft Docs: + The element id which acts as the paint server. + + + + + + Sets the render target's drawing state to that of the specified ID2D1DrawingStateBlock. + Microsoft Docs: + The new drawing state of the render target. + + + + + Creates a device-dependent representation of the fill of the geometry that can be subsequently rendered. + Microsoft Docs: + The geometry to realize. + The flattening tolerance to use when converting Beziers to line segments. This parameter shares the same units as the coordinates of the geometry. + When this method returns, contains the address of a pointer to a new geometry realization object. + + + + + Represents a CPU-based rasterization stage in the transform pipeline graph. + Microsoft Docs: + + + + + This interface performs all the same functions as the existing ID2D1CommandSink4 interface, plus it enables access to the BlendImage method. + Microsoft Docs: + + + + + Provides access to an device context that can accept GDI drawing commands. + Microsoft Docs: + + + + + Describes limitations to be applied to an imaging effect renderer. + Microsoft Docs: + + + + The buffer precision used by default if the buffer precision is not otherwise specified by the effect or by the transform. + + + The tile allocation size to be used by the imaging effect renderer. + + + + This is used to specify the quality of image scaling with ID2D1DeviceContext::DrawImage and with the 2D affine transform effect. + Microsoft Docs: + + + + Samples the nearest single point and uses that exact color. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Sets the extend mode on the y-axis. + Microsoft Docs: + The extend mode on the y-axis of the image. + + + + + Returns the interior points for a gradient mesh patch based on the points defining a Coons patch. + Microsoft Docs: + The coordinate-space location of the control point at position 0. + The coordinate-space location of the control point at position 1. + The coordinate-space location of the control point at position 2. + The coordinate-space location of the control point at position 3. + The coordinate-space location of the control point at position 4. + The coordinate-space location of the control point at position 5. + The coordinate-space location of the control point at position 6. + The coordinate-space location of the control point at position 7. + The coordinate-space location of the control point at position 8. + The coordinate-space location of the control point at position 9. + The coordinate-space location of the control point at position 10. + The coordinate-space location of the control point at position 11. + Returns the interior point for the gradient mesh corresponding to point11 in the D2D1_GRADIENT_MESH_PATCH structure. + Returns the interior point for the gradient mesh corresponding to point12 in the D2D1_GRADIENT_MESH_PATCH structure. + Returns the interior point for the gradient mesh corresponding to point21 in the D2D1_GRADIENT_MESH_PATCH structure. + Returns the interior point for the gradient mesh corresponding to point22 in the D2D1_GRADIENT_MESH_PATCH structure. + + + + + Creates an ID2D1PathGeometry1 object. + Microsoft Docs: + When this method returns, contains the address of a pointer to the newly created path geometry. + + + + + Specifies the antialiasing mode to use for subsequent text and glyph drawing operations. + Microsoft Docs: + The antialiasing mode to use for subsequent text and glyph drawing operations. + + + + + Returns the sine and cosine of an angle. + Microsoft Docs: + The angle to calculate. + The sine of the angle. + The cosine of the angle. + + + + + Specifies how the brush horizontally tiles those areas that extend past its bitmap. + Microsoft Docs: + A value that specifies how the brush horizontally tiles those areas that extend past its bitmap. + + + + + Retrieves the current desktop dots per inch (DPI). To refresh this value, call ReloadSystemMetrics. + Microsoft Docs: + When this method returns, contains the horizontal DPI of the desktop. You must allocate storage for this parameter. + When this method returns, contains the vertical DPI of the desktop. You must allocate storage for this parameter. + + + + + Binds the render target to the device context to which it issues drawing commands. + Microsoft Docs: + The device context to which the render target issues drawing commands. + The dimensions of the handle to a device context (HDC) to which the render target is bound. + + + + + The interpolation mode the Scale effect uses to scale the image. There are 6 scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Speficies whether a flip and/or rotation operation should be performed by the Bitmap source effect. + Microsoft Docs: + + + + The effect doesn't change the orientation of the input. + + + Flips the image horizontally. + + + Rotates the image clockwise 180 degrees. + + + Rotates the image clockwise 180 degrees and flips it horizontally. + + + Rotates the image clockwise 270 degrees and flips it horizontally. + + + Rotates the image clockwise 90 degrees. + + + Rotates the image clockwise 90 degrees and flips it horizontally. + + + Rotates the image clockwise 270 degrees. + + + + Indicates how the intersecting areas of the geometries contained in this geometry group are combined. + Microsoft Docs: + + + + + Returns the number of specified attributes on this element. + Microsoft Docs: + + + + + Specifies how the edges of nontext primitives are rendered. + Microsoft Docs: + + + + Edges are antialiased using the Direct2D per-primitive method of high-quality antialiasing. + + + Objects are aliased in most cases. Objects are antialiased only when they are drawn to a render target created by the CreateDxgiSurfaceRenderTarget method and Direct3D multisampling has been enabled on the backing DirectX Graphics Infrastructure (DXGI) surface. + + + + Sets the ending coordinates of the linear gradient in the brush's coordinate space. + Microsoft Docs: + The ending two-dimensional coordinates of the linear gradient, in the brush's coordinate space. + + + + + Paints the interior of the specified mesh. + Microsoft Docs: + The mesh to paint. + The brush used to paint the mesh. + + + + + Identifiers for properties of the DPI compensation effect. + Microsoft Docs: + + + + The interpolation mode the effect uses to scale the image. + + +The type is D2D1_DPICOMPENSATION_INTERPOLATION_MODE. + +The default value is D2D1_DPICOMPENSATION_INTERPOLATION_MODE_LINEAR. + + + The mode used to calculate the border of the image, soft or hard. See Border modes for more info. + + +The type is D2D1_BORDER_MODE. + +The default value is D2D1_BORDER_MODE_SOFT. + + + The DPI of the input image. + + +The type is FLOAT. + +The default value is 96.0f. + + + + Creates an ID2D1Device1 object. + Microsoft Docs: + The IDXGIDevice object used when creating the ID2D1Device1. + The requested ID2D1Device1 object. + + + + + Indicates whether the buffer precision is supported by the underlying Direct3D device. + Microsoft Docs: + The buffer precision to check. + + + + + Properties of a transformed image source. + Microsoft Docs: + + + + The orientation at which the image source is drawn. + + + The horizontal scale factor at which the image source is drawn. + + + The vertical scale factor at which the image source is drawn. + + + The interpolation mode used when the image source is drawn. This is ignored if the image source is drawn using the DrawImage method, or using an image brush. + + + Image sourc option flags. + + + + Copies the specified triangles to the sink. + Microsoft Docs: + An array of D2D1_TRIANGLE structures that describe the triangles to add to the sink. + The number of triangles to copy from the triangles array. + + + + + Specifies how a geometry is simplified to an ID2D1SimplifiedGeometrySink. + Microsoft Docs: + + + + The output can contain cubic Bezier curves and line segments. + + + The output is flattened so that it contains only line segments. + + + + Copies the specified region from memory into the current bitmap. + Microsoft Docs: + In the current bitmap, the rectangle to which the region specified by srcRect is copied. + The data to copy. + The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory). The stride can be computed from the following formula: pixel width * bytes per pixel + memory padding. + + + + + Represents a path commmand. Each command may reference floats from the segment data. Commands ending in _ABSOLUTE interpret data as absolute coordinate. Commands ending in _RELATIVE interpret data as being relative to the previous point. + Microsoft Docs: + + + + Closes the current subpath. Uses no segment data. + + + Starts a new subpath at the coordinate (x y). Uses 2 floats of segment data. + + + Starts a new subpath at the coordinate (x y). Uses 2 floats of segment data. + + + Draws a line to the coordinate (x y). Uses 2 floats of segment data. + + + Draws a line to the coordinate (x y). Uses 2 floats of segment data. + + + Draws a cubic Bezier curve (x1 y1 x2 y2 x y). The curve ends at (x, y) and is defined by the two control points (x1, y1) and (x2, y2). Uses 6 floats of segment data. + + + Draws a cubic Bezier curve (x1 y1 x2 y2 x y). The curve ends at (x, y) and is defined by the two control points (x1, y1) and (x2, y2). Uses 6 floats of segment data. + + + Draws a quadratic Bezier curve (x1 y1 x y). The curve ends at (x, y) and is defined by the control point (x1 y1). Uses 4 floats of segment data. + + + Draws a quadratic Bezier curve (x1 y1 x y). The curve ends at (x, y) and is defined by the control point (x1 y1). Uses 4 floats of segment data. + + + Draws an elliptical arc (rx ry x-axis-rotation large-arc-flag sweep-flag x y). The curve ends at (x, y) and is defined by the arc parameters. The two flags are + considered set if their values are non-zero. Uses 7 floats of segment data. + + + Draws an elliptical arc (rx ry x-axis-rotation large-arc-flag sweep-flag x y). The curve ends at (x, y) and is defined by the arc parameters. The two flags are + considered set if their values are non-zero. Uses 7 floats of segment data. + + + Draws a horizontal line to the coordinate (x). Uses 1 float of segment data. + + + Draws a horizontal line to the coordinate (x). Uses 1 float of segment data. + + + Draws a vertical line to the coordinate (y). Uses 1 float of segment data. + + + Draws a vertical line to the coordinate (y). Uses 1 float of segment data. + + + Draws a smooth cubic Bezier curve (x2 y2 x y). The curve ends at (x, y) and is defined by the control point (x2, y2). Uses 4 floats of segment data. + + + Draws a smooth cubic Bezier curve (x2 y2 x y). The curve ends at (x, y) and is defined by the control point (x2, y2). Uses 4 floats of segment data. + + + Draws a smooth quadratic Bezier curve ending at (x, y). Uses 2 floats of segment data. + + + Draws a smooth quadratic Bezier curve ending at (x, y). Uses 2 floats of segment data. + + + + Indicates whether a specific ID2D1SimplifiedGeometrySink figure is open or closed. + Microsoft Docs: + + + + The figure is open. + + + The figure is closed. + + + + Adds the given sprites to the end of this sprite batch. + Microsoft Docs: + The number of sprites to be added. This determines how many strides into each given array Direct2D will read. + A pointer to an array containing the destination rectangles specifying where to draw the sprites on the destination device context. + A pointer to an array containing the source rectangles specifying the regions of the source bitmap to draw as sprites. + Direct2D will use the entire source bitmap for sprites that are assigned a null value or the InfiniteRectU. + If this parameter is omitted entirely or set to a null value, then Direct2D will use the entire source bitmap for all the added sprites. + A pointer to an array containing the colors to apply to each sprite. + The output color is the result of component-wise multiplication of the source bitmap color and the provided color. + The output color is not clamped. + + + +Direct2D will not change the color of sprites that are assigned a null value. If this parameter is omitted entirely or set to a null value, + then Direct2D will not change the color of any of the added sprites. + A pointer to an array containing the transforms to apply to each sprite’s destination rectangle. + + +Direct2D will not transform the destination rectangle of any sprites that are assigned a null value. + If this parameter is omitted entirely or set to a null value, + then Direct2D will not transform the destination rectangle of any of the added sprites. + Specifies the distance, in bytes, between each rectangle in the destinationRectangles array. + If you provide a stride of 0, then the same destination rectangle will be used for each added sprite. + Specifies the distance, in bytes, between each rectangle in the sourceRectangles array (if that array is given). + If you provide a stride of 0, then the same source rectangle will be used for each added sprite. + Specifies the distance, in bytes, between each color in the colors array (if that array is given). + If you provide a stride of 0, then the same color will be used for each added sprite. + Specifies the distance, in bytes, between each transform in the transforms array (if that array is given). + If you provide a stride of 0, then the same transform will be used for each added sprite. + + + + + Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the ID2D1Device5 interface, plus it enables the creation of ID2D1DeviceContext6 objects. + Microsoft Docs: + + + + + Retrieves the pre-transform nib shape for this style. + Microsoft Docs: + + + + + Represents a Bezier segment to be used in the creation of an ID2D1Ink object. This structure differs from D2D1_BEZIER_SEGMENT in that it is composed of D2D1_INK_POINTs, which contain a radius in addition to x- and y-coordinates. + Microsoft Docs: + + + + The first control point for the Bezier segment. + + + The second control point for the Bezier segment. + + + The end point for the Bezier segment. + + + + Creates an ID2D1Bitmap whose data is shared with another resource. + Microsoft Docs: + The interface ID of the object supplying the source data. + An ID2D1Bitmap, IDXGISurface, or an IWICBitmapLock that contains the data to share with the new ID2D1Bitmap. For more information, see the Remarks section. + The pixel format and DPI of the bitmap to create . The DXGI_FORMAT portion of the pixel format must match the DXGI_FORMAT of data or the method will fail, but the alpha modes don't have to match. To prevent a mismatch, you can pass NULL or the value obtained from the D2D1::PixelFormat helper function. The DPI settings do not have to match those of data. If both dpiX and dpiY are 0.0f, the DPI of the render target is used. + When this method returns, contains the address of a pointer to the new bitmap. This parameter is passed uninitialized. + + + + + Creates a dash array object which can be used to set the stroke-dasharray property. + Microsoft Docs: + An array of dashes. + Size of the array in th dashes argument. + The created ID2D1SvgStrokeDashArray. + + + + + Sets the value of a text content element. + Microsoft Docs: + The new value of the text content element. + + + + + + This structure allows a ID2D1Bitmap1 to be created with bitmap options and color context information available. + Microsoft Docs: + + + + The DXGI format and alpha mode to create the bitmap with. + + + The bitmap dpi in the x direction. + + + The bitmap dpi in the y direction. + + + The special creation options of the bitmap. + + + The optionally specified color context information. + + + + Removes all sprites from this sprite batch. + Microsoft Docs: + + + + + This interface performs all the same functions as the ID2D1DeviceContext1 interface, plus it enables functionality such as ink rendering, gradient mesh rendering, and improved image loading. + Microsoft Docs: + + + + + Returns the size of the render target in device-independent pixels. + Microsoft Docs: + + + + + Identifiers for properties of the Sepia effect. + Microsoft Docs: + + + + The D2D1_SEPIA_PROP_INTENSITY property is a float value indicating the intesity of the sepia effect. The allowed range is 0.0 to 1.0. The default value is 0.5. + + + The D2D1_SEPIA_PROP_ALPHA_MODE property is a D2D1_ALPHA_MODE enumeration value indicating the alpha mode of the input file. + See the About Alpha Modes section of the Supported Pixel Formats and Alpha Modes topic for additional information.. + The default value is D2D1_ALPHA_MODE_PREMULTIPLIED. + + + + Pushes a clipping rectangle onto the clip and layer stack. + Microsoft Docs: + The rectangle that defines the clip. + The antialias mode for the clip. + + + + + Creates a ID2D1CommandList object. + Microsoft Docs: + When this method returns, contains the address of a pointer to a command list. + + + + + Creates Direct2D resources. + Microsoft Docs: + + + + + Describes a two-dimensional rectangle. + Microsoft Docs: + + + + + Indicates the glyphs to be drawn. + Microsoft Docs: + The upper left corner of the baseline. + The glyphs to render. + Additional non-rendering information about the glyphs. + The brush used to fill the glyphs. + The measuring mode to apply to the glyphs. + + + + + Gets the color profile bytes for an ID2D1ColorContext. + Microsoft Docs: + When this method returns, contains the color profile. + The size of the profile buffer. + + + + + Describes compute shader support, which is an option on D3D10 feature level. + Microsoft Docs: + + + + Shader model 4 compute shaders are supported. + + + + Identifiers for properties of the Hue to RGB effect. + Microsoft Docs: + + + + The D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE property is an enumeration value which indicates which color space to convert from. + The default value for the property is D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_VALUE. + See D2D1_HUETORGB_INPUT_COLOR_SPACE enumeration for more information. + + + + The effect can use this method to do one time initialization tasks. + Microsoft Docs: + An internal context interface that creates and returns effect author–centric types. + The effect can + populate the transform graph with a topology and can update it later. + + + + + Executes all pending drawing commands. + Microsoft Docs: + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + When this method returns, contains the tag for drawing operations that caused errors or 0 if there were no errors. This parameter is passed uninitialized. + + + + + Sets a new primitive blend mode. + Microsoft Docs: + The primitive blend that will apply to subsequent primitives. + + + + + A Direct2D resource that wraps a WMF, EMF, or EMF+ metafile. + Microsoft Docs: + + + + + Gets the last child of this element. + Microsoft Docs: + Outputs the last child of this element. + + + + + Identifiers for properties of the 2D affine transform effect. + Microsoft Docs: + + + + The interpolation mode used to scale the image. There are 6 scale modes that range in quality and speed. + + +Type is D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE. + +Default value is D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR. + + + The mode used to calculate the border of the image, soft or hard. + + +Type is D2D1_BORDER_MODE. + +Default value is D2D1_BORDER_MODE_SOFT. + + + The 3x2 matrix to transform the image using the Direct2D matrix transform. + + +Type is D2D1_MATRIX_3X2_F. + +Default value is Matrix3x2F::Identity(). + + + In the high quality cubic interpolation mode, the sharpness level of the scaling filter as a float between 0 and 1. The values are unitless. You can use sharpness to adjust the quality of an image when you scale the image. + The sharpness factor affects the shape of the kernel. The higher the sharpness factor, the smaller the kernel. + + +
Note  This property affects only the high quality cubic interpolation mode.
+
 
+Type is FLOAT. + +Default value is 1.0f. + + + + Draws a color glyph run that has the format of DWRITE_GLYPH_IMAGE_FORMATS_SVG. + Microsoft Docs: + The origin of the baseline for the glyph run. + The glyphs to render. + The brush used to paint the specified glyphs. + Values for context-fill, context-stroke, and context-value that are used when rendering SVG glyphs. + The index used to select a color palette within a color font. Note that this not the same as the paletteIndex in the + DWRITE_COLOR_GLYPH_RUN struct, which is not relevant for SVG glyphs. + Indicates the measuring method used for text layout. + + + + + Represents an collection of D2D1_GRADIENT_STOP objects for linear and radial gradient brushes. + Microsoft Docs: + + + + + Specifies the alpha mode of the output of the Bitmap source effect. + Microsoft Docs: + + + + The effect output uses premultiplied alpha. + + + The effect output uses straight alpha. + + + + Gets the stroke transform type. + Microsoft Docs: + + + + + Returns the size of the render target in device pixels. + Microsoft Docs: + + + + + Returns the requested stroke parameters. + Microsoft Docs: + Describes how the stroke is painted. + The 'context-value' for the 'stroke-width' property. + The 'context-value' for the 'stroke-dasharray' + property. + The the number of dashes in the dash array. + The 'context-value' for the 'stroke-dashoffset' property. + + + + + Creates a factory object that can be used to create Direct2D resources. + Microsoft Docs: + The threading model of the factory and the resources it creates. + A reference to the IID of ID2D1Factory that is obtained by using __uuidof(ID2D1Factory). + The level of detail provided to the debugging layer. + When this method returns, contains the address to a pointer to the new factory. + + + + + Identifiers for properties of the Convolve matrix effect. + Microsoft Docs: + + + + The size of one unit in the kernel. The units are in (DIPs/kernel unit), where a kernel unit is the size of the element in the convolution kernel. + A value of 1 (DIP/kernel unit) corresponds to one pixel in a image at 96 DPI. + + +The type is FLOAT. + +The default value is 1.0f. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_CONVOLVEMATRIX_SCALE_MODE. + +The default value is D2D1_CONVOLVEMATRIX_SCALE_MODE_LINEAR. + + + The width of the kernel matrix. The units are specified in kernel units. + + +The type is UINT32. + +The default value is 3. + + + The height of the kernel matrix. The units are specified in kernel units. + + +The type is UINT32. + +The default value is 3. + + + The kernel matrix to be applied to the image. The kernel elements aren't bounded and are specified as floats. + + +The first set of KernelSizeX numbers in the FLOAT[] corresponds to the first row in the kernel. + The second set of KernelSizeX numbers correspond to the second row, and so on up to KernelSizeY rows. + +The type is FLOAT[]. + +The default value is {0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f}. + + + The kernel matrix is applied to a pixel and then the result is divided by this value. + + +0 behaves as a value of float epsilon. + +The type is FLOAT. + +The default value is 1.0f. + + + The effect applies the kernel matrix, the divisor, and then the bias is added to the result. The bias is unbounded and unitless. + + +The type is FLOAT. + +The default value is 0.0f. + + + Shifts the convolution kernel from a centered position on the output pixel to a position you specify left/right and up/down. The offset is defined in kernel units. + + +With some offsets and kernel sizes, the convolution kernel’s samples won't land on a pixel image center. The pixel values for the kernel sample are computed by bilinear interpolation. + +The type is D2D1_VECTOR_2F. + +The default value is {0.0f, 0.0f}. + + + Specifies whether the convolution kernel is applied to the alpha channel or only the color channels. + + +If you set this to TRUE the convolution kernel is applied only to the color channels. + +If you set this to FALSE the convolution kernel is applied to all channels. + +The type is BOOL. + +The default value is FALSE. + + + The mode used to calculate the border of the image, soft or hard. + + +The type is D2D1_BORDER_MODE. + +The default value is D2D1_BORDER_MODE_SOFT. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. The effect clamps the values before it premultiplies the alpha. + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + +The type is BOOL. + +The default value is FALSE. + + + + Creates a 3D lookup table for mapping a 3-channel input to a 3-channel output. The table data must be provided in 4-channel format. + Microsoft Docs: + Precision of the input lookup table data. + Number of lookup table elements per dimension (X, Y, Z). + Buffer holding the lookup table data. + Size of the lookup table data buffer. + An array containing two values. The first value is the size in bytes from one row (X dimension) of LUT data to the next. + The second value is the size in bytes from one LUT data plane (X and Y dimensions) to the next. + Receives the new lookup table instance. + + + + + Starts a new figure at the specified point. + Microsoft Docs: + The point at which to begin the new figure. + Whether the new figure should be hollow or filled. + + + + + Specifies how the Crop effect handles the crop rectangle falling on fractional pixel coordinates. + Microsoft Docs: + + + + If the crop rectangle falls on fractional pixel coordinates, the effect applies antialiasing which results in a soft edge. + + + If the crop rectangle falls on fractional pixel coordinates, the effect clamps which results in a hard edge. + + + + Gets the image associated with the image brush. + Microsoft Docs: + When this method returns, contains the address of a pointer to the image associated with this brush. + + + + + Gets the method by which the brush vertically tiles those areas that extend past its bitmap. + Microsoft Docs: + + + + + Describes the caps, miter limit, line join, and dash information for a stroke. + Microsoft Docs: + + + + + Retrieves the factory associated with this resource. + Microsoft Docs: + When this method returns, contains a pointer to a pointer to the factory that created this resource. This parameter is passed uninitialized. + + + + + Set the shader instructions for this transform. + Microsoft Docs: + The resource id for the shader. + Additional information provided to the renderer to indicate the operations the pixel shader does. + + + + + Retrieves the DXGI color space of this context. Returns DXGI_COLOR_SPACE_CUSTOM when color context type is ICC. + Microsoft Docs: + + + + + Draws a rectangle. + Microsoft Docs: + The rectangle to be drawn to the command sink. + The brush used to stroke the geometry. + The width of the stroke. + The style of the stroke. + + + + + Draws a series of glyphs to the device context. + Microsoft Docs: + Origin of first glyph in the series. + The glyphs to render. + Supplementary glyph series information. + The brush that defines the text color. + The measuring mode of the glyph series, used to determine the advances and offsets. The default value is DWRITE_MEASURING_MODE_NATURAL. + + + + + Contains the position and color of a gradient stop. + Microsoft Docs: + + + + A value that indicates the relative position of the gradient stop in the brush. This value must be in the [0.0f, 1.0f] range if the gradient stop is to be seen explicitly. + + + The color of the gradient stop. + + + + Issues drawing commands to a GDI device context. + Microsoft Docs: + + + + + Describes flags that influence how the renderer interacts with a custom vertex shader. + Microsoft Docs: + + + + The logical equivalent of having no flags set. + + + If this flag is set, the renderer assumes that the vertex shader will cover the entire region of interest with vertices and need not clear the destination render target. If this flag is not set, the renderer assumes that the vertices do not cover the entire region interest and must clear the render target to transparent black first. + + + The renderer will use a depth buffer when rendering custom vertices. The depth buffer will be used for calculating occlusion information. This can result in the renderer output being draw-order dependent if it contains transparency. + + + Indicates that custom vertices do not overlap each other. + + + + Indicates whether the HWND associated with this render target is occluded. + Microsoft Docs: + + + + + Identifiers for properties of the Emboss effect. + Microsoft Docs: + + + + The D2D1_EMBOSS_PROP_HEIGHT property is a float value controlling the strength of the embossing effect. The allowed range is 0.0 to 10.0. The default value is 1.0. + + + The D2D1_EMBOSS_PROP_DIRECTION property is a float value specifying the light direction used to create the effect. The allowed range is 0.0 to 360.0. The default value is 0.0. + + + + Gets the value of a text content element. + Microsoft Docs: + The value of the text content element. + The length of the value in the name argument. + + + + + The interpolation mode the DPI compensation effect uses to scale the image. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. Then uses the cubic interpolation mode for the final output. + + + + Describes the extend modes and the interpolation mode of an ID2D1BitmapBrush. + Microsoft Docs: + + + + A value that describes how the brush horizontally tiles those areas that extend past its bitmap. + + + A value that describes how the brush vertically tiles those areas that extend past its bitmap. + + + A value that specifies how the bitmap is interpolated when it is scaled or rotated. + + + + Gets the method by which the brush horizontally tiles those areas that extend past its bitmap. + Microsoft Docs: + + + + + Finds the given resource texture if it has already been created with ID2D1EffectContext::CreateResourceTexture with the same GUID. + Microsoft Docs: + The unique id that identifies the resource texture. + The returned texture that can be used as a resource in a Direct2D effect. + + + + + Renders a given gradient mesh to the target. + Microsoft Docs: + The gradient mesh to be rendered. + + + + + Retrieves the type of shape used at the end of a stroke. + Microsoft Docs: + + + + + Identifiers for properties of the 3D transform effect. + Microsoft Docs: + + + + The interpolation mode the effect uses on the image. There are 5 scale modes that range in quality and speed. + + +Type is D2D1_3DTRANSFORM_INTERPOLATION_MODE. + +Default value is D2D1_3DTRANSFORM_INTERPOLATION_MODE_LINEAR. + + + The mode used to calculate the border of the image, soft or hard. See Border modes for more info. + + +Type is D2D1_BORDER_MODE. + +Default value is D2D1_BORDER_MODE_SOFT. + + + A 4x4 transform matrix applied to the projection plane. The following matrix calculation is used to map points from one 3D coordinate system + to the transformed 2D coordinate system. + + +3D Depth Matrix +Where:
+
X, Y, Z = Input projection plane coordinates
+
Mx,y = Transform Matrix elements +
+
X’, Y’, Z’ =Output projection plane coordinates
+
+ + +The individual matrix elements are not bounded and are unitless. + +Type is D2D1_MATRIX_4X4_F. + +Default value is Matrix4x4F(1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1). + + + + Supplies data to an analysis effect. + Microsoft Docs: + + + + + Gets the root element of the document. + Microsoft Docs: + Outputs the root element of the document. + + + + + Defines when font resources should be subset during printing. + Microsoft Docs: + + + + Uses a heuristic strategy to decide when to subset fonts. + +> [!NOTE] +> If the print driver has requested archive-optimized content, then Direct2D will subset fonts once, for the entire document. + + + Subsets and embeds font resources in each page, then discards that font subset after the page is printed out. + + + Sends out the original font resources without subsetting along with the page that first uses the font, and re-uses the font resources for later pages without resending them. + + + A value that's guaranteed to be a DWORD. + + + + Sets the interpolation mode for the image brush. + Microsoft Docs: + How the contents of the image will be interpolated to handle the brush transform. + + + + + Specifies the x-radius of the gradient ellipse, in the brush's coordinate space. + Microsoft Docs: + The x-radius of the gradient ellipse. This value is in the brush's coordinate space. + + + + + Returns the size, in device-independent pixels (DIPs), of the bitmap. + Microsoft Docs: + + + + + Creates a rotation transformation that rotates by the specified angle about the specified point. + Microsoft Docs: + The clockwise rotation angle, in degrees. + The point about which to rotate. + When this method returns, contains the new rotation transformation. You must allocate storage for this parameter. + + + + + Describes the minimum DirectX support required for hardware rendering by a render target. + Microsoft Docs: + + + + Direct2D determines whether the video card provides adequate hardware rendering support. + + + The video card must support DirectX 9. + + + The video card must support DirectX 10. + + + + This indicates the maximum feature level from the provided list which is supported by the device. + Microsoft Docs: + The feature levels provided by the application. + The count of feature levels provided by the application + The maximum feature level from the featureLevels list which is supported by the D2D device. + + + + + Creates an SVG document from a stream. + Microsoft Docs: + An input stream containing the SVG XML document. If null, an empty document is created. + Size of the initial viewport of the document. + When this method returns, contains a pointer to the created SVG document. + + + + + The alignment portion of the SVG preserveAspectRatio attribute. + Microsoft Docs: + + + + The alignment is set to SVG's 'none' value. + + + The alignment is set to SVG's 'xMinYMin' value. + + + The alignment is set to SVG's 'xMidYMin' value. + + + The alignment is set to SVG's 'xMaxYMin' value. + + + The alignment is set to SVG's 'xMinYMid' value. + + + The alignment is set to SVG's 'xMidYMid' value. + + + The alignment is set to SVG's 'xMaxYMid' value. + + + The alignment is set to SVG's 'xMinYMax' value. + + + The alignment is set to SVG's 'xMidYMax' value. + + + The alignment is set to SVG's 'xMaxYMax' value. + + + + Sets the properties of the output buffer of the specified transform node. + Microsoft Docs: + The number of bits and the type of the output buffer. + The number of channels in the output buffer (1 or 4). + + + + + Defines a range of vertices that are used when rendering less than the full contents of a vertex buffer. + Microsoft Docs: + + + + The first vertex in the range to process. + + + The number of vertices to use. + + + + Defines a resource texture when the original resource texture is created. + Microsoft Docs: + + + + The extents of the resource table in each dimension. + + + The number of dimensions in the resource texture. This must be a number from 1 to 3. + + + The precision of the resource texture to create. + + + The number of channels in the resource texture. + + + The filtering mode to use on the texture. + + + Specifies how pixel values beyond the extent of the texture will be sampled, in every dimension. + + + + The blend mode used for the Blend effect. + Microsoft Docs: + + + + Basic blend formula for alpha only. + +Mathematical formula for a mutiply effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a screen effect. + + + Basic blend formula for alpha only. + +mathematical formula for a darken effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a lighten effect. + + + Given: + + +
    +
  • A scene coordinate XY for the current pixel
    • +
  • A deterministic pseudo-random number generator rand(XY) based on seed coordinate XY, with unbiased distribution of values from [0, 1]
    • +
+Mathematical formula for a dissolve blend effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a coor burn effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a linear burn effect. + + + Basic blend formula for alpha only. + +Mathematical formla for a darken color effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a lighter color effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a color dodge effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a linear dodge effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for an overlay effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a soft light effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a hard light effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a vivid light effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a linear light effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a pin light effect. + + + Basic blend formulas with f(FRGB, BRGB) = + +Mathematical formula for a hard mix effect. + + + Basic blend formulas with f(FRGB, BRGB) = abs(FRGB - BRGB) + + + Basic blend formulas with f(FRGB, BRGB) = FRGB + BRGB – 2 * FRGB * BRGB + + + Basic blend formula for alpha only. + +Mathematical formula for a hue blend effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a sturation blend effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a color blend effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a luminosity blend effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a subtract blend effect. + + + Basic blend formula for alpha only. + +Mathematical formula for a division blend effect. + + + + Gets the document that contains this element. + Microsoft Docs: + Ouputs the document that contains this element. This argument will be null if the element has been removed from the tree. + + + + + Interface describing an SVG points value in a polyline or polygon element. + Microsoft Docs: + + + + + Indicates the behavior of the gradient outside the normalized gradient range. + Microsoft Docs: + + + + + Gets the size of the layer in device-independent pixels. + Microsoft Docs: + + + + + This interface performs all the same functions as the existing ID2D1CommandSink1 interface. It also enables access to ink rendering and gradient mesh rendering. + Microsoft Docs: + + + + + Retrieves the color interpolation mode that the gradient stop collection uses. + Microsoft Docs: + + + + + Returns the output rectangle of the support transform. + Microsoft Docs: + The output bounds. + + + + + Specifies a value for the SVG display property. + Microsoft Docs: + + + + The element uses the default display behavior. + + + The element and all children are not rendered directly. + + + + Indicates whether the specified matrix is invertible. + Microsoft Docs: + The matrix to test. + + + + + Indicates the geometry to be drawn to the command sink. + Microsoft Docs: + The geometry to be stroked. + The brush that will be used to fill the stroked geometry. + The width of the stroke. + The style of the stroke. + + + + + The interpolation mode the Spot-diffuse lighting effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. + Then uses the cubic interpolation mode for the final output. + + + + Identifiers for properties of the Shadow effect. + Microsoft Docs: + + + + The amount of blur to be applied to the alpha channel of the image. You can compute the blur radius of the kernel by multiplying the standard deviation by 3. + The units of both the standard deviation and blur radius are DIPs. + + +This property is the same as the Gaussian Blur standard deviation property. + +The type is FLOAT. + +The default value is 3.0f. + + + The color of the drop shadow. This property is a D2D1_VECTOR_4F defined as: (R, G, B, A). You must specify this color in straight alpha. + + +The type is D2D1_VECTOR_4F. + +The default value is {0.0f, 0.0f, 0.0f, 1.0f}. + + + The level of performance optimization. + + +The type is D2D1_SHADOW_OPTIMIZATION. + +The default value is D2D1_SHADOW_OPTIMIZATION_BALANCED. + + + + The interpolation mode the 3D perspective transform effect uses on the image. There are 5 scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode uses more processing time than the nearest neighbor mode, but outputs a higher quality image. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + + Specifies the method used to determine which points are inside the geometry described by this geometry sink and which points are outside. + Microsoft Docs: + The method used to determine whether a given point is part of the geometry. + + + + + Converts the given color from one colorspace to another. + Microsoft Docs: + The source color space. + The destination color space. + The source color. + + + + + Retrieves the ID2D1GradientStopCollection associated with this linear gradient brush. + Microsoft Docs: + The ID2D1GradientStopCollection object associated with this linear gradient brush object. This parameter is passed uninitialized. + + + + + Interface describing an SVG attribute. + Microsoft Docs: + + + + + Creates Direct2D resources. This interface also enables the creation of ID2D1Device2 objects. + Microsoft Docs: + + + + + Gets the device associated with a device context. + Microsoft Docs: + When this method returns, contains the address of a pointer to a Direct2D device associated with this device context. + + + + + Passes all remaining resources to the print sub-system, then clean up and close the current print job. + Microsoft Docs: + + + + + Identifiers for the properties of the Color matrix effect. + Microsoft Docs: + + + + A 5x4 matrix of float values. The elements in the matrix are not bounded and are unitless. + + +The type is D2D1_MATRIX_5X4_F. + +The default value is the identity matrix, Matrix5x4F(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0). + + + The alpha mode of the output. + + +The type is D2D1_COLORMATRIX_ALPHA_MODE. + +The default value is D2D1_COLORMATRIX_ALPHA_MODE_PREMULTIPLIED. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. + The effect clamps the values before it premultiplies the alpha. + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + +The type is BOOL. + +The default value is FALSE. + + + + Saves the current drawing state to the specified ID2D1DrawingStateBlock. + Microsoft Docs: + When this method returns, contains the current drawing state of the render target. This parameter must be initialized before passing it to the method. + + + + + Identifiers for properties of the Atlas effect. + Microsoft Docs: + + + + The portion of the image passed to the next effect. + Type is D2D1_VECTOR_4F. + Default value is (-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX). + + + The maximum size sampled for the output rectangle. + Type is D2D1_VECTOR_4F. + Default value is (-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX). + + + + Indicates when ID2D1CommandSink processing has completed. + Microsoft Docs: + + + + + Specifies the interpolation mode used when the brush bitmap is scaled or rotated. + Microsoft Docs: + The interpolation mode used when the brush bitmap is scaled or rotated. + + + + + Represents a resource domain whose objects and device contexts can be used together. + Microsoft Docs: + + + + + This interface performs all the same functions as the existing ID2D1GdiMetafile interface. It also enables accessing the metafile DPI and bounds. + Microsoft Docs: + + + + + Specifies how one of the color sources is to be derived and optionally specifies a preblend operation on the color source. + Microsoft Docs: + + + + The data source is black (0, 0, 0, 0). There is no preblend operation. + + + The data source is white (1, 1, 1, 1). There is no preblend operation. + + + The data source is color data (RGB) from the second input of the blend transform. There is not a preblend operation. + + + The data source is color data (RGB) from second input of the blend transform. The preblend operation inverts the data, generating 1 - RGB. + + + The data source is alpha data (A) from second input of the blend transform. There is no preblend operation. + + + The data source is alpha data (A) from the second input of the blend transform. The preblend operation inverts the data, generating 1 - A. + + + The data source is alpha data (A) from the first input of the blend transform. There is no preblend operation. + + + The data source is alpha data (A) from the first input of the blend transform. The preblend operation inverts the data, generating 1 - A. + + + The data source is color data from the first input of the blend transform. There is no preblend operation. + + + The data source is color data from the first input of the blend transform. The preblend operation inverts the data, generating 1 - RGB. + + + The data source is alpha data from the second input of the blend transform. The preblend operation clamps the data to 1 or less. + + + The data source is the blend factor. There is no preblend operation. + + + The data source is the blend factor. The preblend operation inverts the blend factor, generating 1 - blend_factor. + + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. + Then uses the cubic interpolation mode for the final output. + + + + Gets the bounds of an image without the world transform of the context applied. + Microsoft Docs: + The image whose bounds will be calculated. + When this method returns, contains a pointer to the bounds of the image in device independent pixels (DIPs) and in local space. + + + + + The bitmap or command list to which the Direct2D device context will now render. + Microsoft Docs: + The surface or command list to which the Direct2D device context will render. + + + + + Creates a color context from an IWICColorContext. The D2D1ColorContext space of the resulting context varies, see Remarks for more info. + Microsoft Docs: + The IWICColorContext used to initialize the color context. + When this method returns, contains the address of a pointer to a new color context. + + + + + Values for the D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA property of the Highlights and Shadows effect. + Microsoft Docs: + + + + Indicates the input image is in linear gamma space. + + + Indicates the input image is sRGB gamma space. + + + + Retrieves the underlying bitmap image source from the Windows Imaging Component (WIC). + Microsoft Docs: + On return contains the bitmap image source. + + + + + Gets the number of inputs to the transform node. + Microsoft Docs: + + + + + Updates the segment data array. Existing segment data not updated by this method are preserved. The array is resized larger if necessary to accomodate the new segment data. + Microsoft Docs: + The data array. + The number of data to update. + The index at which to begin updating segment data. Must be less than or equal to the size of the segment data array. + + + + + Provides the GPU render info interface to the transform implementation. + Microsoft Docs: + The interface supplied back to the calling method to allow it to specify the GPU based transform pass. + + + + + Specifies whether text snapping is suppressed or clipping to the layout rectangle is enabled. This enumeration allows a bitwise combination of its member values. + Microsoft Docs: + + + + Text is not vertically snapped to pixel boundaries. This setting is recommended for text that is being animated. + + + Text is clipped to the layout rectangle. + + + In Windows 8.1 and later, text is rendered using color versions of glyphs, if defined by the font. + + + Bitmap origins of color glyph bitmaps are not snapped. + + + Text is vertically snapped to pixel boundaries and is not clipped to the layout rectangle. + + + + This interface performs all the same functions as the existing ID2D1GdiMetafileSink interface. It also enables access to metafile records. + Microsoft Docs: + + + + + Sets the paint type. + Microsoft Docs: + The new paint type. + + + + + The renderer calls this method to provide the effect implementation with a way to specify its transform graph and transform graph changes. + Microsoft Docs: + The graph to which the effect describes its transform topology through the SetDescription call. + + + + + Updates the points array. Existing points not updated by this method are preserved. The array is resized larger if necessary to accomodate the new points. + Microsoft Docs: + The points array. + The number of points to update. + The index at which to begin updating points. Must be less than or equal to the size of the array. + + + + + Allows the operating system to free the video memory of resources by discarding their content. + Microsoft Docs: + + + + + Copies the specified region from the specified render target into the current bitmap. + Microsoft Docs: + In the current bitmap, the upper-left corner of the area to which the region specified by srcRect is copied. + The render target that contains the region to copy. + The area of renderTarget to copy. + + + + + Specifies the chroma subsampling of the input chroma image used by the YCbCr effect. + Microsoft Docs: + + + + This mode attempts to infer the chroma subsampling from the bounds of the input images. When this option is selected, + the smaller plane is upsampled to the size of the larger plane and this effect’s output rectangle is the intersection of the two planes. + When using this mode, care should be taken when applying effects to the input planes that change the image bounds, such as the border transform, + so that the desired size ratio between the planes is maintained. + + + The chroma plane is horizontally subsampled by 1/2 and vertically subsampled by 1/2. + When this option is selected, the chroma plane is horizontally and vertically upsampled by 2x and this effect's output rectangle is the intersection of the two planes. + + + The chroma plane is horizontally subsampled by 1/2. When this option is selected, + the chroma plane is horizontally upsampled by 2x and this effect's output rectangle is the intersection of the two planes. + + + The chroma plane is not subsampled. When this option is selected this effect’s output rectangle is the intersection of the two planes. + + + The chroma plane is vertically subsampled by 1/2. When this option is selected, the chroma plane is vertically upsampled by 2x and this effect's + output rectangle is the intersection of the two planes. + + + + Describes a rounded rectangle. + Microsoft Docs: + + + + + Creates an empty ID2D1PathGeometry. + Microsoft Docs: + When this method returns, contains the address to a pointer to the path geometry created by this method. + + + + + Represents a color context to be used with the Color Management Effect. + Microsoft Docs: + + + + + Defines a blend description to be used in a particular blend transform. + Microsoft Docs: + + + + Specifies the first RGB data source and includes an optional preblend operation. + + + Specifies the second RGB data source and includes an optional preblend operation. + + + Specifies how to combine the RGB data sources. + + + Specifies the first alpha data source and includes an optional preblend operation. Blend options that end in _COLOR are not allowed. + + + Specifies the second alpha data source and includes an optional preblend operation. Blend options that end in _COLOR are not allowed. + + + Specifies how to combine the alpha data sources. + + + Parameters to the blend operations. The blend must use D2D1_BLEND_BLEND_FACTOR for this to be used. + + + + Creates a new Direct2D device associated with the provided DXGI device. + Microsoft Docs: + The DXGI device the Direct2D device is associated with. + The properties to apply to the Direct2D device. + When this function returns, contains the address of a pointer to a Direct2D device. + + + + + Enables specification of information for a compute-shader rendering pass. + Microsoft Docs: + + + + + Retrieves the specified subset of sprites from this sprite batch. For the best performance, use nullptr for properties that you do not need to retrieve. + Microsoft Docs: + The index of the first sprite in this sprite batch to retrieve. + The number of sprites to retrieve. + When this method returns, contains a pointer to an array containing the destination rectangles for the retrieved sprites. + When this method returns, contains a pointer to an array containing the source rectangles for the retrieved sprites. + + + +The InfiniteRectU is returned for any sprites that were not assigned a source rectangle. + When this method returns, contains a pointer to an array containing the colors to be applied to the retrieved sprites. + + + +The color {1.0f, 1.0f, 1.0f, 1.0f} is returned for any sprites that were not assigned a color. + When this method returns, contains a pointer to an array containing the transforms to be applied to the retrieved sprites. + + + +The identity matrix is returned for any sprites that were not assigned a transform. + + + + + Creates a new ID2D1GradientMesh instance using the given array of patches. + Microsoft Docs: + A pointer to the array containing the patches to be used in this mesh. + The number of patches in the patches argument to read. + When this method returns, contains the address of a pointer to the new gradient mesh. + + + + + This method allows a compute-shader–based transform to select the number of thread groups to execute based on the number of output pixels it needs to fill. + Microsoft Docs: + The output rectangle that will be filled by the compute transform. + The number of threads in the x dimension. + The number of threads in the y dimension. + The number of threads in the z dimension. + + + + + Deserializes a subtree from the stream. The stream must have only one root element, but that root element need not be an 'svg' element. The output element is not inserted into this document tree. + Microsoft Docs: + An input stream containing the SVG XML subtree. + The root of the subtree. + + + + + Sets the D2D1_DRAWING_STATE_DESCRIPTION1 associated with this drawing state block. + Microsoft Docs: + The D2D1_DRAWING_STATE_DESCRIPTION1 to be set associated with this drawing state block. + + + + + Represents a collection of style properties to be used by methods like ID2D1DeviceContext2::DrawInkwhen rendering ink. The ink style defines the nib (pen tip) shape and transform. + Microsoft Docs: + + + + + Replaces the oldChild element with the newChild. + Microsoft Docs: + The element to be inserted. + The child element to be replaced. The oldChild element must be an immediate child of this element. + + + + + Identifiers for properties of the Discrete transfer effect. + Microsoft Docs: + + + + The list of values used to define the transfer function for the Red channel. + + +The type is FLOAT[]. + +The default value is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Red channel. + If you set this to FALSE the effect applies the RedDiscreteTransfer function to the Red channel. + + +The type is BOOL. + +The default value if FALSE. + + + The list of values used to define the transfer function for the Green channel. + + +The type is FLOAT[]. + +The default value is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Green channel. + If you set this to FALSE the effect applies the GreenDiscreteTransfer function to the Green channel. + + +The type is BOOL. + +The default value if FALSE. + + + The list of values used to define the transfer function for the Blue channel. + + +The type is FLOAT[]. + +The default value is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Blue channel. + If you set this to FALSE the effect applies the BlueDiscreteTransfer function to the Blue channel. + + +The type is BOOL. + +The default value if FALSE. + + + The list of values used to define the transfer function for the Alpha channel. + + +The type is FLOAT[]. + +The default value is {0.0f, 1.0f}. + + + If you set this to TRUE the effect does not apply the transfer function to the Alpha channel. + If you set this to FALSE the effect applies the AlphaDiscreteTransfer function to the Alpha channel. + + +The type is BOOL. + +The default value if FALSE. + + + Whether the effect clamps color values to between 0 and 1 before the effect passes the values to the next effect in the graph. + The effect clamps the values before it premultiplies the alpha. + + + +If you set this to TRUE the effect will clamp the values. If you set this to FALSE, the effect will not clamp the color values, + but other effects and the output surface may clamp the values if they are not of high enough precision. + +The type is BOOL. + +The default value if FALSE. + + + + Gets the string length of an attribute of this element. + Microsoft Docs: + The name of the attribute. + The string type of the attribute. + The lengthe of the attribute. The returned string length does not include room for the null terminator. + + + + + Creates Direct2D resources. This interface also enables the creation of ID2D1Device4 objects. + Microsoft Docs: + + + + + Sets the image associated with the provided image brush. + Microsoft Docs: + The image to be associated with the image brush. + + + + + Copies the gradient stops from the collection into memory. + Microsoft Docs: + When this method returns, contains a pointer to a one-dimensional array of D2D1_GRADIENT_STOP structures. + The number of gradient stops to copy. + + + + + Clears the drawing area to the specified color. + Microsoft Docs: + The color to which the command sink should be cleared. + + + + + Renders the given ink object using the given brush and ink style. + Microsoft Docs: + The ink object to be rendered. + The brush with which to render the ink object. + The ink style to use when rendering the ink object. + + + + + Maps the given bitmap into memory. + Microsoft Docs: + The options used in mapping the bitmap into memory. + When this method returns, contains a reference to the rectangle that is mapped into memory. + + + + + Specifies stroke and join options to be applied to new segments added to the geometry sink. + Microsoft Docs: + Stroke and join options to be applied to new segments added to the geometry sink. + + + + + The alpha mode of the output of the Color matrix effect. + Microsoft Docs: + + + + The effect un-premultiplies the input, applies the color matrix, and premultiplies the output. + + + The effect applies the color matrix directly to the input, and doesn't premultiply the output. + + + + Sets a new primitive blend mode. + Microsoft Docs: + The primitive blend that will apply to subsequent primitives. + + + + + Represents a basic image-processing construct in Direct2D. + Microsoft Docs: + + + + + Removes the provided node from the transform graph. + Microsoft Docs: + The node that will be removed from the transform graph. + + + + + Contains the data format and alpha mode for a bitmap or render target. + Microsoft Docs: + + + + A value that specifies the size and arrangement of channels in each pixel. + + + A value that specifies whether the alpha channel is using pre-multiplied alpha, straight alpha, whether it should be ignored and considered opaque, or whether it is unkown. + + + + Creates an image source from a set of DXGI surface(s). The YCbCr surface(s) are converted to RGBA automatically during subsequent drawing. + Microsoft Docs: + The DXGI surfaces to create the image source from. + The number of surfaces provided; must be between one and three. + The color space of the input. + Options controlling color space conversions. + Receives the new image source instance. + + + + + Indicates the number of geometry objects in the geometry group. + Microsoft Docs: + + + + + Creates a gradient stop collection, enabling the gradient to contain color channels with values outside of [0,1] and also enabling rendering to a high-color render target with interpolation in sRGB space. + Microsoft Docs: + An array of color values and offsets. + The number of elements in the gradientStops array. + Specifies both the input color space and the space in which the color interpolation occurs. + The color space that colors will be converted to after interpolation occurs. + The precision of the texture used to hold interpolated values. + +
Note  This method will fail if the underlying Direct3D device does not support the requested buffer precision. Use ID2D1DeviceContext::IsBufferPrecisionSupported to determine what is supported. +
+
 
+ Defines how colors outside of the range defined by the stop collection are determined. + Defines how colors are interpolated. D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED is the default, see Remarks for more info. + The new gradient stop collection. + + + + + Gets the bounds of an image with the world transform of the context applied. + Microsoft Docs: + The image whose bounds will be calculated. + When this method returns, contains a pointer to the bounds of the image in device independent pixels (DIPs). + + + + + Defines the properties of a vertex buffer that are standard for all vertex shader definitions. + Microsoft Docs: + + + + The number of inputs to the vertex shader. + + + Indicates how frequently the vertex buffer is likely to be updated. + + + The initial contents of the vertex buffer. + + + The size of the vertex buffer, in bytes. + + + + Contains the debugging level of an ID2D1Factory object. + Microsoft Docs: + + + + The debugging level of the ID2D1Factory object. + + + + Sets a vertex buffer, a corresponding vertex shader, and options to control how the vertices are to be handled by the Direct2D context. + Microsoft Docs: + The vertex buffer, if this is cleared, the default vertex shader and mapping to the transform rectangles will be used. + Options that influence how the renderer will interact with the vertex shader. + How the vertices will be blended with the output texture. + The set of vertices to use from the buffer. + The GUID of the vertex shader. + + + + + Describes the caps, miter limit, line join, and dash information for a stroke. + Microsoft Docs: + + + + + Describes a geometric path that does not contain quadratic bezier curves or arcs. + Microsoft Docs: + + + + + Describes whether an opacity mask contains graphics or text. Direct2D uses this information to determine which gamma space to use when blending the opacity mask. + Microsoft Docs: + + + + The opacity mask contains graphics. The opacity mask is blended in the gamma 2.2 color space. + + + The opacity mask contains non-GDI text. The gamma space used for blending is obtained from the render target's text rendering parameters. (ID2D1RenderTarget::SetTextRenderingParams). + + + The opacity mask contains text rendered using the GDI-compatible rendering mode. The opacity mask is blended using the gamma for GDI rendering. + + + + Encapsulates a device- and transform-dependent representation of a filled or stroked geometry. + Microsoft Docs: + + + + + Used to specify the geometric blend mode for all Direct2D primitives. + Microsoft Docs: + + + + The standard source-over-destination blend mode. + + + The source is copied to the destination; the destination pixels are ignored. + + + The resulting pixel values use the minimum of the source and destination pixel values. Available in Windows 8 and later. + + + The resulting pixel values are the sum of the source and destination pixel values. Available in Windows 8 and later. + + + The resulting pixel values use the maximum of the source and destination pixel values. + Available in Windows 10 and later (set using ID21CommandSink4::SetPrimitiveBlend2). + + + + Interface for all SVG elements. + Microsoft Docs: + + + + + Defines an object that paints an area. Interfaces that derive from ID2D1Brush describe how the area is painted. + Microsoft Docs: + + + + + Renders part or all of the given sprite batch to the device context using the specified drawing options. + Microsoft Docs: + The sprite batch to draw. + The index of the first sprite in the sprite batch to draw. + The number of sprites to draw. + The bitmap from which the sprites are to be sourced. Each sprite’s source rectangle refers to a portion of this bitmap. + The interpolation mode to use when drawing this sprite batch. This determines how Direct2D interpolates pixels within the drawn sprites if scaling is performed. + The additional drawing options, if any, to be used for this sprite batch. + + + + + Wraps an effect graph into a single transform node and then inserted into a transform graph. This allows an effect to aggregate other effects. + Microsoft Docs: + The effect to be wrapped in a transform node. + The returned transform node that encapsulates the effect graph. + + + + + Describes an elliptical arc between two points. + Microsoft Docs: + + + + The end point of the arc. + + + The x-radius and y-radius of the arc. + + + A value that specifies how many degrees in the clockwise direction the ellipse is rotated relative to the current coordinate system. + + + A value that specifies whether the arc sweep is clockwise or counterclockwise. + + + A value that specifies whether the given arc is larger than 180 degrees. + + + + Retrieves the antialiasing mode, transform, and tags portion of the drawing state. + Microsoft Docs: + When this method returns, contains the antialiasing mode, transform, and tags portion of the drawing state. You must allocate storage for this parameter. + + + + + Removes commands from the end of the commands array. + Microsoft Docs: + Specifies how many commands to remove. + + + + + This object supplies the values for context-fill, context-stroke, and context-value that are used when rendering SVG glyphs. + Microsoft Docs: + + + + + Renders drawing instructions to a window. + Microsoft Docs: + + + + + Instructs the command list to stop accepting commands so that you can use it as an input to an effect or in a call to ID2D1DeviceContext::DrawImage. + Microsoft Docs: + + + + + Retrieves the current antialiasing mode for nontext drawing operations. + Microsoft Docs: + + + + + Indicates how the Color management effect should interpret alpha data that is contained in the input image. + Microsoft Docs: + + + + The effect assumes the alpha mode is premultiplied. + + + The effect assumes the alpha mode is straight. + + + + Sets the antialiasing mode that will be used to render any subsequent geometry. + Microsoft Docs: + The antialiasing mode selected for the command list. + + + + + Gets points from the points array. + Microsoft Docs: + Buffer to contain the points. + The element count of the buffer. + The index of the first point to retrieve. + + + + + Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the existing ID2D1Device1 interface. It also enables the creation of ID2D1DeviceContext2 objects. + Microsoft Docs: + + + + + The level of performance optimization for the Shadow effect. + Microsoft Docs: + + + + Applies internal optimizations such as pre-scaling at relatively small radii. Uses linear filtering. + + + Uses the same optimization thresholds as Speed mode, but uses trilinear filtering. + + + Only uses internal optimizations with large blur radii, where approximations are less likely to be visible. Uses trilinear filtering. + + + + Gets the number of inputs to the effect. + Microsoft Docs: + + + + + Paints an area with a bitmap. + Microsoft Docs: + + + + + Specifies the algorithm that is used when images are scaled or rotated. + Microsoft Docs: + + + + Use the exact color of the nearest bitmap pixel to the current rendering pixel. + + + Interpolate a color from the four bitmap pixels that are the nearest to the rendering pixel. + + + + Adds the given segments to the end of this ink object. + Microsoft Docs: + A pointer to an array of segments to be added to this ink object. + The number of segments to be added to this ink object. + + + + + Describes the opacity and transformation of a brush. + Microsoft Docs: + + + + A value between 0.0f and 1.0f, inclusive, that specifies the degree of opacity of the brush. + + + The transformation that is applied to the brush. + + + + Defines constants that identify the top level properties of the HDR Tone Map effect. + Microsoft Docs: + + + + Identifies the InputMaxLuminance property of the effect. The property is of type FLOAT, and is specified in nits. + + + Identifies the OutputMaxLuminance property of the effect. The property is of type FLOAT, and is specified in nits. + + + Identifies the DisplayMode property of the effect. The property is of type D2D1_HDRTONEMAP_DISPLAY_MODE. + + + + Identifiers for properties of the Morphology effect. + Microsoft Docs: + + + + The morphology mode. + + +The type is D2D1_MORPHOLOGY_MODE. + +The default value is D2D1_MORPHOLOGY_MODE_ERODE. + + + Size of the kernel in the X direction. The units are in DIPs. Values must be between 1 and 100 inclusive. + + +The type is UINT. + +The default value is 1. + + + Size of the kernel in the Y direction. The units are in DIPs. Values must be between 1 and 100 inclusive. + + +The type is UINT. + +The default value is 1. + + + + Represents an image source which shares resources with an original image source. + Microsoft Docs: + + + + + Specifies how the brush vertically tiles those areas that extend past its bitmap. + Microsoft Docs: + A value that specifies how the brush vertically tiles those areas that extend past its bitmap. + + + + + Indicates whether a specific ID2D1SimplifiedGeometrySink figure is filled or hollow. + Microsoft Docs: + + + + Indicates the figure will be filled by the FillGeometry (ID2D1CommandSink::FillGeometry + or ID2D1RenderTarget::FillGeometry) method. + + + Indicates the figure will not be filled by the FillGeometry (ID2D1CommandSink::FillGeometry + or ID2D1RenderTarget::FillGeometry) method and will only consist of an outline. + Moreover, the bounds of a hollow figure are zero. + D2D1_FIGURE_BEGIN_HOLLOW should be used for stroking, or for other geometry operations. + + + + Returns the current interpolation mode of the brush. + Microsoft Docs: + + + + + Draws a line drawn between two points. + Microsoft Docs: + The start point of the line. + The end point of the line. + The brush used to fill the line. + The width of the stroke to fill the line. + The style of the stroke. If not specified, the stroke is solid. + + + + + Gets the degree of opacity of this brush. + Microsoft Docs: + + + + + Creates a skew transformation that has the specified x-axis angle, y-axis angle, and center point. + Microsoft Docs: + The x-axis skew angle, which is measured in degrees counterclockwise from the y-axis. + The y-axis skew angle, which is measured in degrees counterclockwise from the x-axis. + The center point of the skew operation. + When this method returns, contains the rotation transformation. You must allocate storate for this parameter. + + + + + This indicates whether an optional capability is supported by the D3D device. + Microsoft Docs: + The feature to query support for. + A structure indicating information about how or if the feature is supported. + The size of the featureSupportData parameter. + + + + + Paints an area with a linear gradient. + Microsoft Docs: + + + + + Produces 2D pixel data that has been sourced from WIC. + Microsoft Docs: + + + + + Represents a set of vertices that form a list of triangles. + Microsoft Docs: + + + + + Represents a resource domain whose objects and device contexts can be used together. + Microsoft Docs: + + + + + Identifiers for properties of the Temperature and Tint effect. + Microsoft Docs: + + + + The D2D1_TEMPERATUREANDTINT_PROP_TEMPERATURE property is a float value specifying how much to increase or decrease the temperature of the input image. The allowed range is -1.0 to 1.0. The default value is 0.0. + + + The D2D1_TEMPERATUREANDTINT_PROP_TINT property is a float value specifying how much to increase or decrease the tint of the input image. The allowed range is -1.0 to 1.0. The default value is 0.0. + + + + Retrieves an image of the color bitmap glyph from the color glyph cache. + Microsoft Docs: + The format for the glyph image. + If there is no image data in the requested format for the requested glyph, this method will return an error. + The origin for the glyph. + Reference to a font face which contains font face type, appropriate file references, face identification data and various font data such as metrics, names and glyph outlines. + The specified font size affects the choice of which bitmap to use from the font. It also affects the output glyphTransform, causing it to properly scale the glyph. + Index of the glyph. + If true, specifies that glyphs are rotated 90 degrees to the left and vertical metrics are used. Vertical writing is achieved by specifying isSideways as true and rotating the entire run 90 degrees to the right via a rotate transform. + The transform to apply to the image. This input transform affects the choice of which bitmap to use from the font. It is also factored into the output glyphTransform. + Dots per inch along the x-axis. + Dots per inch along the y-axis. + Output transform, which transforms from the glyph's space to the same output space as the worldTransform. This includes the input + glyphOrigin, the glyph's offset from the glyphOrigin, and any other required transformations. + On completion contains the retrieved glyph image. + + + + + Represents an SVG length. + Microsoft Docs: + + + + + Specifies how the memory to be mapped from the corresponding ID2D1Bitmap1 should be treated. + Microsoft Docs: + + + + Allow CPU Read access. + + + Allow CPU Write access. + + + Discard the previous contents of the resource when it is mapped. + + + + Identifiers for properties of the Distant-specular lighting effect. + Microsoft Docs: + + + + The direction angle of the light source in the XY plane relative to the X-axis in the counter clock wise direction. The units are in degrees and must be between 0 and 360 degrees. + + +The type is FLOAT. + +The default value is 0.0f. + + + The direction angle of the light source in the YZ plane relative to the Y-axis in the counter clock wise direction. The units are in degrees and must be between 0 and 360 degrees. + + +The type is FLOAT. + +The default value is 0.0f. + + + The exponent for the specular term in the Phong lighting equation. A larger value corresponds to a more reflective surface. The value is unitless and must be between 1.0 and 128. + + +The type is FLOAT. + +The default value is 1.0f. + + + The ratio of specular reflection to the incoming light. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The scale factor in the Z direction. The value is unitless and must be between 0 and 10,000. + + +The type is FLOAT. + +The default value is 1.0f. + + + The color of the incoming light. This property is exposed as a D2D1_VECTOR_3F – (R, G, B) and used to compute LR, LG, LB. + + +The type is D2D1_VECTOR_3F. + +The default value is {1.0f, 1.0f, 1.0f}. + + + The size of an element in the Sobel kernel used to generate the surface normal in the X and Y direction. This property is a D2D1_VECTOR_2F (Kernel Unit Length X, Kernel Unit Length Y) and is defined in (device-independent pixels (DIPs)/Kernel Unit). The effect uses bilinear interpolation to scale the bitmap to match size of kernel elements. + + +The type is D2D1_VECTOR_2F. + +The default value is {1.0f, 1.0f}. + + + The interpolation mode the effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + + +The type is D2D1_DISTANTSPECULAR_SCALE_MODE. + +The default value is D2D1_DISTANTSPECULAR_SCALE_MODE_LINEAR. + + + + Gets the unit mapping that an effect will use for properties that could be in either dots per inch (dpi) or pixels. + Microsoft Docs: + The dpi on the x-axis. + The dpi on the y-axis. + + + + + Sets the resource texture corresponding to the given shader texture index to the given texture resource. + Microsoft Docs: + The index to set the resource texture on. + The resource texture object to set on the shader texture index. + + + + + Defines options that should be applied to the color space. + Microsoft Docs: + + + + The color space is otherwise described, such as with a color profile. + + + The color space is sRGB. + + + The color space is scRGB. + + + + Prepares an effect for the rendering process. + Microsoft Docs: + Indicates the type of change the effect should expect. + + + + + Creates or finds the given resource texture, depending on whether a resource id is specified. + Microsoft Docs: + An optional pointer to the unique id that identifies the lookup table. + The properties used to create the resource texture. + The optional data to be loaded into the resource texture. + An optional pointer to the stride to advance through the resource texture, according to dimension. + The size, in bytes, of the data. + The returned texture that can be used as a resource in a Direct2D effect. + + + + + Clears the transform nodes and all connections from the transform graph. + Microsoft Docs: + + + + + Changes the blend description of the corresponding blend transform object. + Microsoft Docs: + The new blend description specified for the blend transform. + + + + + The interpolation mode the Distant-specular lighting effect uses to scale the image to the corresponding kernel unit length. There are six scale modes that range in quality and speed. + Microsoft Docs: + + + + Samples the nearest single point and uses that. This mode uses less processing time, but outputs the lowest quality image. + + + Uses a four point sample and linear interpolation. This mode outputs a higher quality image than nearest neighbor. + + + Uses a 16 sample cubic kernel for interpolation. This mode uses the most processing time, but outputs a higher quality image. + + + Uses 4 linear samples within a single pixel for good edge anti-aliasing. This mode is good for scaling down by small amounts on images with few pixels. + + + Uses anisotropic filtering to sample a pattern according to the transformed shape of the bitmap. + + + Uses a variable size high quality cubic kernel to perform a pre-downscale the image if downscaling is involved in the transform matrix. + Then uses the cubic interpolation mode for the final output. + + + + Defines a property binding to a pair of functions which get and set the corresponding property. + Microsoft Docs: + + + + The name of the property. + + + The function that will receive the data to set. + + + The function that will be asked to write the output data. + + + + Gets the extend mode in the x direction. + Microsoft Docs: + + + + + Retrieves the specified subset of segments stored in this ink object. + Microsoft Docs: + The index of the first segment in this ink object to retrieve. + When this method returns, contains a pointer to an array of retrieved segments. + The number of segments to retrieve. Note that segmentsCount must be less than or equal to the number of segments in the ink object minus startSegment. + + + + + Draws a text layout object. If the layout is not subsequently changed, this can be more efficient than DrawText when drawing the same layout repeatedly. + Microsoft Docs: + The point, described in device-independent pixels, at which the upper-left corner of the text described by textLayout is drawn. + The formatted text to draw. Any drawing effects that do not inherit from ID2D1Resource are ignored. If there are drawing effects that inherit from ID2D1Resource that are not brushes, this method fails and the render target is put in an error state. + The brush used to paint the text. + The values for context-fill, context-stroke, and context-value that are used when rendering SVG glyphs. + The index used to select a color palette within a color font. + A value that indicates whether the text should be snapped to pixel boundaries and whether the text should be clipped to the layout rectangle. + The default value is D2D1_DRAW_TEXT_OPTIONS_NONE, + which indicates that text should be snapped to pixel boundaries and it should not be clipped to the layout rectangle. + + + + + Creates a sequence of cubic Bezier curves and adds them to the geometry sink. + Microsoft Docs: + A pointer to an array of Bezier segments that describes the Bezier curves to create. A curve is drawn from the geometry sink's current point (the end point of the last segment drawn or the location specified by BeginFigure) to the end point of the first Bezier segment in the array. if the array contains additional Bezier segments, each subsequent Bezier segment uses the end point of the preceding Bezier segment as its start point. + The number of Bezier segments in the beziers array. + + + + + Sets what units will be used to interpret values passed into the device context. + Microsoft Docs: + An enumeration defining how passed-in units will be interpreted by the device context. + + + + + Allows a custom effect's interface and behavior to be specified by the effect author. + Microsoft Docs: + + + + + Controls option flags for a new ID2D1ImageSource when it is created. + Microsoft Docs: + + + + No options are used. + + + Indicates the image source should release its reference to the WIC bitmap source after it has initialized. + By default, the image source retains a reference to the WIC bitmap source for the lifetime of the object to enable quality and speed optimizations for printing. + This option disables that optimization. + + + Indicates the image source should only populate subregions of the image cache on-demand. You can control this behavior using + the EnsureCached + and TrimCache methods. + This options provides the ability to improve memory usage by only keeping needed portions of the image in memory. + This option requires that the image source has a reference to the WIC bitmap source, and is incompatible with D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE. + + + + Sets the output node for the transform graph. + Microsoft Docs: + The node that will be considered the output of the transform node. + + + + + Gets the extend mode of the image brush on the y-axis of the image. + Microsoft Docs: + + + + + Draws an image to the device context using the specified blend mode. Results are equivalent to using Direct2D's built-in Blend effect. + Microsoft Docs: + The image to be drawn to the device context. + The blend mode to be used. See Blend modes for more info. + The offset in the destination space that the image will be rendered to. + The entire logical extent of the image will be rendered to the corresponding destination. + If not specified, the destination origin will be (0, 0). + The top-left corner of the image will be mapped to the target offset. + This will not necessarily be the origin. The default value is NULL. + The corresponding rectangle in the image space will be mapped to the given origins when processing the image. The default value is NULL. + The interpolation mode that will be used to scale the image if necessary. The default value is D2D1_INTERPOLATION_MODE_LINEAR. + + + \ No newline at end of file diff --git a/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs b/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs new file mode 100644 index 0000000..e358e65 --- /dev/null +++ b/src/Vortice.Win32/Generated/Graphics/DirectWrite.cs @@ -0,0 +1,21259 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Numerics; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Diagnostics.CodeAnalysis; + +#if !NET6_0_OR_GREATER +using MemoryMarshal = Win32.MemoryMarshal; +#endif + +namespace Win32.Graphics.DirectWrite; + +public static partial class Apis +{ + public const uint DWRITE_ALPHA_MAX = 255; + public const uint FACILITY_DWRITE = 2200; + public const uint DWRITE_ERR_BASE = 20480; + public static readonly HResult DWRITE_E_REMOTEFONT = -2003283955; + public static readonly HResult DWRITE_E_DOWNLOADCANCELLED = -2003283954; + public static readonly HResult DWRITE_E_DOWNLOADFAILED = -2003283953; + public static readonly HResult DWRITE_E_TOOMANYDOWNLOADS = -2003283952; +} + +#region Enums +/// +/// DWRITE_FONT_AXIS_TAG +public enum FontAxisTag : uint +{ + /// + /// DWRITE_FONT_AXIS_TAG_WEIGHT + Weight = 1952999287, + /// + /// DWRITE_FONT_AXIS_TAG_WIDTH + Width = 1752458359, + /// + /// DWRITE_FONT_AXIS_TAG_SLANT + Slant = 1953393779, + /// + /// DWRITE_FONT_AXIS_TAG_OPTICAL_SIZE + OpticalSize = 2054385775, + /// + /// DWRITE_FONT_AXIS_TAG_ITALIC + Italic = 1818326121, +} + +/// +/// DWRITE_MEASURING_MODE +public enum MeasuringMode : int +{ + /// + /// DWRITE_MEASURING_MODE_NATURAL + Natural = 0, + /// + /// DWRITE_MEASURING_MODE_GDI_CLASSIC + GDIClassic = 1, + /// + /// DWRITE_MEASURING_MODE_GDI_NATURAL + GDINatural = 2, +} + +/// +/// DWRITE_GLYPH_IMAGE_FORMATS +[Flags] +public enum GlyphImageFormats : uint +{ + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_NONE + None = 0, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE + Truetype = 1, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_CFF + Cff = 2, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_COLR + Colr = 4, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_SVG + Svg = 8, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_PNG + Png = 16, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_JPEG + Jpeg = 32, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_TIFF + Tiff = 64, + /// + /// DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8 + PremultipliedB8g8r8a8 = 128, +} + +/// +/// DWRITE_FONT_FILE_TYPE +public enum FontFileType : int +{ + /// + /// DWRITE_FONT_FILE_TYPE_UNKNOWN + Unknown = 0, + /// + /// DWRITE_FONT_FILE_TYPE_CFF + Cff = 1, + /// + /// DWRITE_FONT_FILE_TYPE_TRUETYPE + Truetype = 2, + /// + /// DWRITE_FONT_FILE_TYPE_OPENTYPE_COLLECTION + OpentypeCollection = 3, + /// + /// DWRITE_FONT_FILE_TYPE_TYPE1_PFM + Type1Pfm = 4, + /// + /// DWRITE_FONT_FILE_TYPE_TYPE1_PFB + Type1Pfb = 5, + /// + /// DWRITE_FONT_FILE_TYPE_VECTOR + Vector = 6, + /// + /// DWRITE_FONT_FILE_TYPE_BITMAP + Bitmap = 7, + /// + /// DWRITE_FONT_FILE_TYPE_TRUETYPE_COLLECTION + TruetypeCollection = 3, +} + +/// +/// DWRITE_FONT_FACE_TYPE +public enum FontFaceType : int +{ + /// + /// DWRITE_FONT_FACE_TYPE_CFF + Cff = 0, + /// + /// DWRITE_FONT_FACE_TYPE_TRUETYPE + Truetype = 1, + /// + /// DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION + OpentypeCollection = 2, + /// + /// DWRITE_FONT_FACE_TYPE_TYPE1 + Type1 = 3, + /// + /// DWRITE_FONT_FACE_TYPE_VECTOR + Vector = 4, + /// + /// DWRITE_FONT_FACE_TYPE_BITMAP + Bitmap = 5, + /// + /// DWRITE_FONT_FACE_TYPE_UNKNOWN + Unknown = 6, + /// + /// DWRITE_FONT_FACE_TYPE_RAW_CFF + RawCff = 7, + /// + /// DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION + TruetypeCollection = 2, +} + +/// +/// DWRITE_FONT_SIMULATIONS +[Flags] +public enum FontSimulations : uint +{ + /// + /// DWRITE_FONT_SIMULATIONS_NONE + None = 0, + /// + /// DWRITE_FONT_SIMULATIONS_BOLD + Bold = 1, + /// + /// DWRITE_FONT_SIMULATIONS_OBLIQUE + Oblique = 2, +} + +/// +/// DWRITE_FONT_WEIGHT +public enum FontWeight : int +{ + /// + /// DWRITE_FONT_WEIGHT_THIN + Thin = 100, + /// + /// DWRITE_FONT_WEIGHT_EXTRA_LIGHT + ExtraLight = 200, + /// + /// DWRITE_FONT_WEIGHT_ULTRA_LIGHT + UltraLight = 200, + /// + /// DWRITE_FONT_WEIGHT_LIGHT + Light = 300, + /// + /// DWRITE_FONT_WEIGHT_SEMI_LIGHT + SemiLight = 350, + /// + /// DWRITE_FONT_WEIGHT_NORMAL + Normal = 400, + /// + /// DWRITE_FONT_WEIGHT_REGULAR + Regular = 400, + /// + /// DWRITE_FONT_WEIGHT_MEDIUM + Medium = 500, + /// + /// DWRITE_FONT_WEIGHT_DEMI_BOLD + DemiBold = 600, + /// + /// DWRITE_FONT_WEIGHT_SEMI_BOLD + SemiBold = 600, + /// + /// DWRITE_FONT_WEIGHT_BOLD + Bold = 700, + /// + /// DWRITE_FONT_WEIGHT_EXTRA_BOLD + ExtraBold = 800, + /// + /// DWRITE_FONT_WEIGHT_ULTRA_BOLD + UltraBold = 800, + /// + /// DWRITE_FONT_WEIGHT_BLACK + Black = 900, + /// + /// DWRITE_FONT_WEIGHT_HEAVY + Heavy = 900, + /// + /// DWRITE_FONT_WEIGHT_EXTRA_BLACK + ExtraBlack = 950, + /// + /// DWRITE_FONT_WEIGHT_ULTRA_BLACK + UltraBlack = 950, +} + +/// +/// DWRITE_FONT_STRETCH +public enum FontStretch : int +{ + /// + /// DWRITE_FONT_STRETCH_UNDEFINED + Undefined = 0, + /// + /// DWRITE_FONT_STRETCH_ULTRA_CONDENSED + UltraCondensed = 1, + /// + /// DWRITE_FONT_STRETCH_EXTRA_CONDENSED + ExtraCondensed = 2, + /// + /// DWRITE_FONT_STRETCH_CONDENSED + Condensed = 3, + /// + /// DWRITE_FONT_STRETCH_SEMI_CONDENSED + SemiCondensed = 4, + /// + /// DWRITE_FONT_STRETCH_NORMAL + Normal = 5, + /// + /// DWRITE_FONT_STRETCH_MEDIUM + Medium = 5, + /// + /// DWRITE_FONT_STRETCH_SEMI_EXPANDED + SemiExpanded = 6, + /// + /// DWRITE_FONT_STRETCH_EXPANDED + Expanded = 7, + /// + /// DWRITE_FONT_STRETCH_EXTRA_EXPANDED + ExtraExpanded = 8, + /// + /// DWRITE_FONT_STRETCH_ULTRA_EXPANDED + UltraExpanded = 9, +} + +/// +/// DWRITE_FONT_STYLE +public enum FontStyle : int +{ + /// + /// DWRITE_FONT_STYLE_NORMAL + Normal = 0, + /// + /// DWRITE_FONT_STYLE_OBLIQUE + Oblique = 1, + /// + /// DWRITE_FONT_STYLE_ITALIC + Italic = 2, +} + +/// +/// DWRITE_INFORMATIONAL_STRING_ID +public enum InformationalStringId : int +{ + /// + /// DWRITE_INFORMATIONAL_STRING_NONE + DWRITE_INFORMATIONAL_STRING_NONE = 0, + /// + /// DWRITE_INFORMATIONAL_STRING_COPYRIGHT_NOTICE + DWRITE_INFORMATIONAL_STRING_COPYRIGHT_NOTICE = 1, + /// + /// DWRITE_INFORMATIONAL_STRING_VERSION_STRINGS + DWRITE_INFORMATIONAL_STRING_VERSION_STRINGS = 2, + /// + /// DWRITE_INFORMATIONAL_STRING_TRADEMARK + DWRITE_INFORMATIONAL_STRING_TRADEMARK = 3, + /// + /// DWRITE_INFORMATIONAL_STRING_MANUFACTURER + DWRITE_INFORMATIONAL_STRING_MANUFACTURER = 4, + /// + /// DWRITE_INFORMATIONAL_STRING_DESIGNER + DWRITE_INFORMATIONAL_STRING_DESIGNER = 5, + /// + /// DWRITE_INFORMATIONAL_STRING_DESIGNER_URL + DWRITE_INFORMATIONAL_STRING_DESIGNER_URL = 6, + /// + /// DWRITE_INFORMATIONAL_STRING_DESCRIPTION + DWRITE_INFORMATIONAL_STRING_DESCRIPTION = 7, + /// + /// DWRITE_INFORMATIONAL_STRING_FONT_VENDOR_URL + DWRITE_INFORMATIONAL_STRING_FONT_VENDOR_URL = 8, + /// + /// DWRITE_INFORMATIONAL_STRING_LICENSE_DESCRIPTION + DWRITE_INFORMATIONAL_STRING_LICENSE_DESCRIPTION = 9, + /// + /// DWRITE_INFORMATIONAL_STRING_LICENSE_INFO_URL + DWRITE_INFORMATIONAL_STRING_LICENSE_INFO_URL = 10, + /// + /// DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES = 11, + /// + /// DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES = 12, + /// + /// DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES = 13, + /// + /// DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES = 14, + /// + /// DWRITE_INFORMATIONAL_STRING_SAMPLE_TEXT + DWRITE_INFORMATIONAL_STRING_SAMPLE_TEXT = 15, + /// + /// DWRITE_INFORMATIONAL_STRING_FULL_NAME + DWRITE_INFORMATIONAL_STRING_FULL_NAME = 16, + /// + /// DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME + DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME = 17, + /// + /// DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME + DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME = 18, + /// + /// DWRITE_INFORMATIONAL_STRING_WEIGHT_STRETCH_STYLE_FAMILY_NAME + DWRITE_INFORMATIONAL_STRING_WEIGHT_STRETCH_STYLE_FAMILY_NAME = 19, + /// + /// DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG + DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG = 20, + /// + /// DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG + DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG = 21, + /// + /// DWRITE_INFORMATIONAL_STRING_PREFERRED_FAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_PREFERRED_FAMILY_NAMES = 13, + /// + /// DWRITE_INFORMATIONAL_STRING_PREFERRED_SUBFAMILY_NAMES + DWRITE_INFORMATIONAL_STRING_PREFERRED_SUBFAMILY_NAMES = 14, + /// + /// DWRITE_INFORMATIONAL_STRING_WWS_FAMILY_NAME + DWRITE_INFORMATIONAL_STRING_WWS_FAMILY_NAME = 19, +} + +/// +/// DWRITE_FACTORY_TYPE +public enum FactoryType : int +{ + /// + /// DWRITE_FACTORY_TYPE_SHARED + Shared = 0, + /// + /// DWRITE_FACTORY_TYPE_ISOLATED + Isolated = 1, +} + +/// +/// DWRITE_PIXEL_GEOMETRY +public enum PixelGeometry : int +{ + /// + /// DWRITE_PIXEL_GEOMETRY_FLAT + Flat = 0, + /// + /// DWRITE_PIXEL_GEOMETRY_RGB + Rgb = 1, + /// + /// DWRITE_PIXEL_GEOMETRY_BGR + Bgr = 2, +} + +/// +/// DWRITE_RENDERING_MODE +public enum RenderingMode : int +{ + /// + /// DWRITE_RENDERING_MODE_DEFAULT + Default = 0, + /// + /// DWRITE_RENDERING_MODE_ALIASED + Aliased = 1, + /// + /// DWRITE_RENDERING_MODE_GDI_CLASSIC + GDIClassic = 2, + /// + /// DWRITE_RENDERING_MODE_GDI_NATURAL + GDINatural = 3, + /// + /// DWRITE_RENDERING_MODE_NATURAL + Natural = 4, + /// + /// DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC + NaturalSymmetric = 5, + /// + /// DWRITE_RENDERING_MODE_OUTLINE + Outline = 6, + /// + /// DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC + CleartypeGDIClassic = 2, + /// + /// DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL + CleartypeGDINatural = 3, + /// + /// DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL + CleartypeNatural = 4, + /// + /// DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL_SYMMETRIC + CleartypeNaturalSymmetric = 5, +} + +/// +/// DWRITE_READING_DIRECTION +public enum ReadingDirection : int +{ + /// + /// DWRITE_READING_DIRECTION_LEFT_TO_RIGHT + LeftToRight = 0, + /// + /// DWRITE_READING_DIRECTION_RIGHT_TO_LEFT + RightToLeft = 1, + /// + /// DWRITE_READING_DIRECTION_TOP_TO_BOTTOM + TopToBottom = 2, + /// + /// DWRITE_READING_DIRECTION_BOTTOM_TO_TOP + BottomToTop = 3, +} + +/// +/// DWRITE_FLOW_DIRECTION +public enum FlowDirection : int +{ + /// + /// DWRITE_FLOW_DIRECTION_TOP_TO_BOTTOM + TopToBottom = 0, + /// + /// DWRITE_FLOW_DIRECTION_BOTTOM_TO_TOP + BottomToTop = 1, + /// + /// DWRITE_FLOW_DIRECTION_LEFT_TO_RIGHT + LeftToRight = 2, + /// + /// DWRITE_FLOW_DIRECTION_RIGHT_TO_LEFT + RightToLeft = 3, +} + +/// +/// DWRITE_TEXT_ALIGNMENT +public enum TextAlignment : int +{ + /// + /// DWRITE_TEXT_ALIGNMENT_LEADING + Leading = 0, + /// + /// DWRITE_TEXT_ALIGNMENT_TRAILING + Trailing = 1, + /// + /// DWRITE_TEXT_ALIGNMENT_CENTER + Center = 2, + /// + /// DWRITE_TEXT_ALIGNMENT_JUSTIFIED + Justified = 3, +} + +/// +/// DWRITE_PARAGRAPH_ALIGNMENT +public enum ParagraphAlignment : int +{ + /// + /// DWRITE_PARAGRAPH_ALIGNMENT_NEAR + Near = 0, + /// + /// DWRITE_PARAGRAPH_ALIGNMENT_FAR + Far = 1, + /// + /// DWRITE_PARAGRAPH_ALIGNMENT_CENTER + Center = 2, +} + +/// +/// DWRITE_WORD_WRAPPING +public enum WordWrapping : int +{ + /// + /// DWRITE_WORD_WRAPPING_WRAP + Wrap = 0, + /// + /// DWRITE_WORD_WRAPPING_NO_WRAP + NoWrap = 1, + /// + /// DWRITE_WORD_WRAPPING_EMERGENCY_BREAK + EmergencyBreak = 2, + /// + /// DWRITE_WORD_WRAPPING_WHOLE_WORD + WholeWord = 3, + /// + /// DWRITE_WORD_WRAPPING_CHARACTER + Character = 4, +} + +/// +/// DWRITE_LINE_SPACING_METHOD +public enum LineSpacingMethod : int +{ + /// + /// DWRITE_LINE_SPACING_METHOD_DEFAULT + Default = 0, + /// + /// DWRITE_LINE_SPACING_METHOD_UNIFORM + Uniform = 1, + /// + /// DWRITE_LINE_SPACING_METHOD_PROPORTIONAL + Proportional = 2, +} + +/// +/// DWRITE_TRIMMING_GRANULARITY +public enum TrimmingGranularity : int +{ + /// + /// DWRITE_TRIMMING_GRANULARITY_NONE + None = 0, + /// + /// DWRITE_TRIMMING_GRANULARITY_CHARACTER + Character = 1, + /// + /// DWRITE_TRIMMING_GRANULARITY_WORD + Word = 2, +} + +/// +/// DWRITE_FONT_FEATURE_TAG +public enum FontFeatureTag : uint +{ + /// + /// DWRITE_FONT_FEATURE_TAG_ALTERNATIVE_FRACTIONS + AlternativeFractions = 1668441697, + /// + /// DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS_FROM_CAPITALS + PetiteCapitalsFromCapitals = 1668297315, + /// + /// DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS_FROM_CAPITALS + SmallCapitalsFromCapitals = 1668493923, + /// + /// DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_ALTERNATES + ContextualAlternates = 1953259875, + /// + /// DWRITE_FONT_FEATURE_TAG_CASE_SENSITIVE_FORMS + CaseSensitiveForms = 1702060387, + /// + /// DWRITE_FONT_FEATURE_TAG_GLYPH_COMPOSITION_DECOMPOSITION + GlyphCompositionDecomposition = 1886217059, + /// + /// DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_LIGATURES + ContextualLigatures = 1734962275, + /// + /// DWRITE_FONT_FEATURE_TAG_CAPITAL_SPACING + CapitalSpacing = 1886613603, + /// + /// DWRITE_FONT_FEATURE_TAG_CONTEXTUAL_SWASH + ContextualSwash = 1752658787, + /// + /// DWRITE_FONT_FEATURE_TAG_CURSIVE_POSITIONING + CursivePositioning = 1936880995, + /// + /// DWRITE_FONT_FEATURE_TAG_DEFAULT + Default = 1953261156, + /// + /// DWRITE_FONT_FEATURE_TAG_DISCRETIONARY_LIGATURES + DiscretionaryLigatures = 1734962276, + /// + /// DWRITE_FONT_FEATURE_TAG_EXPERT_FORMS + ExpertForms = 1953527909, + /// + /// DWRITE_FONT_FEATURE_TAG_FRACTIONS + Fractions = 1667330662, + /// + /// DWRITE_FONT_FEATURE_TAG_FULL_WIDTH + FullWidth = 1684633446, + /// + /// DWRITE_FONT_FEATURE_TAG_HALF_FORMS + HalfForms = 1718378856, + /// + /// DWRITE_FONT_FEATURE_TAG_HALANT_FORMS + HalantForms = 1852596584, + /// + /// DWRITE_FONT_FEATURE_TAG_ALTERNATE_HALF_WIDTH + AlternateHalfWidth = 1953259880, + /// + /// DWRITE_FONT_FEATURE_TAG_HISTORICAL_FORMS + HistoricalForms = 1953720680, + /// + /// DWRITE_FONT_FEATURE_TAG_HORIZONTAL_KANA_ALTERNATES + HorizontalKanaAlternates = 1634626408, + /// + /// DWRITE_FONT_FEATURE_TAG_HISTORICAL_LIGATURES + HistoricalLigatures = 1734962280, + /// + /// DWRITE_FONT_FEATURE_TAG_HALF_WIDTH + HalfWidth = 1684633448, + /// + /// DWRITE_FONT_FEATURE_TAG_HOJO_KANJI_FORMS + HojoKanjiForms = 1869246312, + /// + /// DWRITE_FONT_FEATURE_TAG_JIS04_FORMS + Jis04Forms = 875589738, + /// + /// DWRITE_FONT_FEATURE_TAG_JIS78_FORMS + Jis78Forms = 943157354, + /// + /// DWRITE_FONT_FEATURE_TAG_JIS83_FORMS + Jis83Forms = 859336810, + /// + /// DWRITE_FONT_FEATURE_TAG_JIS90_FORMS + Jis90Forms = 809070698, + /// + /// DWRITE_FONT_FEATURE_TAG_KERNING + Kerning = 1852990827, + /// + /// DWRITE_FONT_FEATURE_TAG_STANDARD_LIGATURES + StandardLigatures = 1634167148, + /// + /// DWRITE_FONT_FEATURE_TAG_LINING_FIGURES + LiningFigures = 1836412524, + /// + /// DWRITE_FONT_FEATURE_TAG_LOCALIZED_FORMS + LocalizedForms = 1818455916, + /// + /// DWRITE_FONT_FEATURE_TAG_MARK_POSITIONING + MarkPositioning = 1802658157, + /// + /// DWRITE_FONT_FEATURE_TAG_MATHEMATICAL_GREEK + MathematicalGreek = 1802659693, + /// + /// DWRITE_FONT_FEATURE_TAG_MARK_TO_MARK_POSITIONING + MarkToMarkPositioning = 1802333037, + /// + /// DWRITE_FONT_FEATURE_TAG_ALTERNATE_ANNOTATION_FORMS + AlternateAnnotationForms = 1953259886, + /// + /// DWRITE_FONT_FEATURE_TAG_NLC_KANJI_FORMS + NlcKanjiForms = 1801677934, + /// + /// DWRITE_FONT_FEATURE_TAG_OLD_STYLE_FIGURES + OldStyleFigures = 1836412527, + /// + /// DWRITE_FONT_FEATURE_TAG_ORDINALS + Ordinals = 1852076655, + /// + /// DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_ALTERNATE_WIDTH + ProportionalAlternateWidth = 1953259888, + /// + /// DWRITE_FONT_FEATURE_TAG_PETITE_CAPITALS + PetiteCapitals = 1885430640, + /// + /// DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_FIGURES + ProportionalFigures = 1836412528, + /// + /// DWRITE_FONT_FEATURE_TAG_PROPORTIONAL_WIDTHS + ProportionalWidths = 1684633456, + /// + /// DWRITE_FONT_FEATURE_TAG_QUARTER_WIDTHS + QuarterWidths = 1684633457, + /// + /// DWRITE_FONT_FEATURE_TAG_REQUIRED_LIGATURES + RequiredLigatures = 1734962290, + /// + /// DWRITE_FONT_FEATURE_TAG_RUBY_NOTATION_FORMS + RubyNotationForms = 2036495730, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_ALTERNATES + StylisticAlternates = 1953259891, + /// + /// DWRITE_FONT_FEATURE_TAG_SCIENTIFIC_INFERIORS + ScientificInferiors = 1718511987, + /// + /// DWRITE_FONT_FEATURE_TAG_SMALL_CAPITALS + SmallCapitals = 1885564275, + /// + /// DWRITE_FONT_FEATURE_TAG_SIMPLIFIED_FORMS + SimplifiedForms = 1819307379, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_1 + StylisticSet1 = 825258867, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_2 + StylisticSet2 = 842036083, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_3 + StylisticSet3 = 858813299, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_4 + StylisticSet4 = 875590515, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_5 + StylisticSet5 = 892367731, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_6 + StylisticSet6 = 909144947, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_7 + StylisticSet7 = 925922163, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_8 + StylisticSet8 = 942699379, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_9 + StylisticSet9 = 959476595, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_10 + StylisticSet10 = 808547187, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_11 + StylisticSet11 = 825324403, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_12 + StylisticSet12 = 842101619, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_13 + StylisticSet13 = 858878835, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_14 + StylisticSet14 = 875656051, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_15 + StylisticSet15 = 892433267, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_16 + StylisticSet16 = 909210483, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_17 + StylisticSet17 = 925987699, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_18 + StylisticSet18 = 942764915, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_19 + StylisticSet19 = 959542131, + /// + /// DWRITE_FONT_FEATURE_TAG_STYLISTIC_SET_20 + StylisticSet20 = 808612723, + /// + /// DWRITE_FONT_FEATURE_TAG_SUBSCRIPT + Subscript = 1935832435, + /// + /// DWRITE_FONT_FEATURE_TAG_SUPERSCRIPT + Superscript = 1936749939, + /// + /// DWRITE_FONT_FEATURE_TAG_SWASH + Swash = 1752397683, + /// + /// DWRITE_FONT_FEATURE_TAG_TITLING + Titling = 1819568500, + /// + /// DWRITE_FONT_FEATURE_TAG_TRADITIONAL_NAME_FORMS + TraditionalNameForms = 1835101812, + /// + /// DWRITE_FONT_FEATURE_TAG_TABULAR_FIGURES + TabularFigures = 1836412532, + /// + /// DWRITE_FONT_FEATURE_TAG_TRADITIONAL_FORMS + TraditionalForms = 1684107892, + /// + /// DWRITE_FONT_FEATURE_TAG_THIRD_WIDTHS + ThirdWidths = 1684633460, + /// + /// DWRITE_FONT_FEATURE_TAG_UNICASE + Unicase = 1667853941, + /// + /// DWRITE_FONT_FEATURE_TAG_VERTICAL_WRITING + VerticalWriting = 1953654134, + /// + /// DWRITE_FONT_FEATURE_TAG_VERTICAL_ALTERNATES_AND_ROTATION + VerticalAlternatesAndRotation = 846492278, + /// + /// DWRITE_FONT_FEATURE_TAG_SLASHED_ZERO + SlashedZero = 1869768058, +} + +/// +/// DWRITE_SCRIPT_SHAPES +[Flags] +public enum ScriptShapes : uint +{ + None = 0, + /// + /// DWRITE_SCRIPT_SHAPES_DEFAULT + Default = 0, + /// + /// DWRITE_SCRIPT_SHAPES_NO_VISUAL + NoVisual = 1, +} + +/// +/// DWRITE_BREAK_CONDITION +public enum BreakCondition : int +{ + /// + /// DWRITE_BREAK_CONDITION_NEUTRAL + Neutral = 0, + /// + /// DWRITE_BREAK_CONDITION_CAN_BREAK + CanBreak = 1, + /// + /// DWRITE_BREAK_CONDITION_MAY_NOT_BREAK + MayNotBreak = 2, + /// + /// DWRITE_BREAK_CONDITION_MUST_BREAK + MustBreak = 3, +} + +/// +/// DWRITE_NUMBER_SUBSTITUTION_METHOD +public enum NumberSubstitutionMethod : int +{ + /// + /// DWRITE_NUMBER_SUBSTITUTION_METHOD_FROM_CULTURE + FromCulture = 0, + /// + /// DWRITE_NUMBER_SUBSTITUTION_METHOD_CONTEXTUAL + Contextual = 1, + /// + /// DWRITE_NUMBER_SUBSTITUTION_METHOD_NONE + None = 2, + /// + /// DWRITE_NUMBER_SUBSTITUTION_METHOD_NATIONAL + National = 3, + /// + /// DWRITE_NUMBER_SUBSTITUTION_METHOD_TRADITIONAL + Traditional = 4, +} + +/// +/// DWRITE_TEXTURE_TYPE +public enum TextureType : int +{ + /// + /// DWRITE_TEXTURE_ALIASED_1x1 + DWRITE_TEXTURE_ALIASED_1x1 = 0, + /// + /// DWRITE_TEXTURE_CLEARTYPE_3x1 + DWRITE_TEXTURE_CLEARTYPE_3x1 = 1, +} + +/// +/// DWRITE_PANOSE_FAMILY +public enum PanoseFamily : int +{ + /// + /// DWRITE_PANOSE_FAMILY_ANY + Any = 0, + /// + /// DWRITE_PANOSE_FAMILY_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_FAMILY_TEXT_DISPLAY + TextDisplay = 2, + /// + /// DWRITE_PANOSE_FAMILY_SCRIPT + Script = 3, + /// + /// DWRITE_PANOSE_FAMILY_DECORATIVE + Decorative = 4, + /// + /// DWRITE_PANOSE_FAMILY_SYMBOL + Symbol = 5, + /// + /// DWRITE_PANOSE_FAMILY_PICTORIAL + Pictorial = 5, +} + +/// +/// DWRITE_PANOSE_SERIF_STYLE +public enum PanoseSerifStyle : int +{ + /// + /// DWRITE_PANOSE_SERIF_STYLE_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SERIF_STYLE_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SERIF_STYLE_COVE + Cove = 2, + /// + /// DWRITE_PANOSE_SERIF_STYLE_OBTUSE_COVE + ObtuseCove = 3, + /// + /// DWRITE_PANOSE_SERIF_STYLE_SQUARE_COVE + SquareCove = 4, + /// + /// DWRITE_PANOSE_SERIF_STYLE_OBTUSE_SQUARE_COVE + ObtuseSquareCove = 5, + /// + /// DWRITE_PANOSE_SERIF_STYLE_SQUARE + Square = 6, + /// + /// DWRITE_PANOSE_SERIF_STYLE_THIN + Thin = 7, + /// + /// DWRITE_PANOSE_SERIF_STYLE_OVAL + Oval = 8, + /// + /// DWRITE_PANOSE_SERIF_STYLE_EXAGGERATED + Exaggerated = 9, + /// + /// DWRITE_PANOSE_SERIF_STYLE_TRIANGLE + Triangle = 10, + /// + /// DWRITE_PANOSE_SERIF_STYLE_NORMAL_SANS + NormalSans = 11, + /// + /// DWRITE_PANOSE_SERIF_STYLE_OBTUSE_SANS + ObtuseSans = 12, + /// + /// DWRITE_PANOSE_SERIF_STYLE_PERPENDICULAR_SANS + PerpendicularSans = 13, + /// + /// DWRITE_PANOSE_SERIF_STYLE_FLARED + Flared = 14, + /// + /// DWRITE_PANOSE_SERIF_STYLE_ROUNDED + Rounded = 15, + /// + /// DWRITE_PANOSE_SERIF_STYLE_SCRIPT + Script = 16, + /// + /// DWRITE_PANOSE_SERIF_STYLE_PERP_SANS + PerpSans = 13, + /// + /// DWRITE_PANOSE_SERIF_STYLE_BONE + Bone = 8, +} + +/// +/// DWRITE_PANOSE_WEIGHT +public enum PanoseWeight : int +{ + /// + /// DWRITE_PANOSE_WEIGHT_ANY + Any = 0, + /// + /// DWRITE_PANOSE_WEIGHT_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_WEIGHT_VERY_LIGHT + VeryLight = 2, + /// + /// DWRITE_PANOSE_WEIGHT_LIGHT + Light = 3, + /// + /// DWRITE_PANOSE_WEIGHT_THIN + Thin = 4, + /// + /// DWRITE_PANOSE_WEIGHT_BOOK + Book = 5, + /// + /// DWRITE_PANOSE_WEIGHT_MEDIUM + Medium = 6, + /// + /// DWRITE_PANOSE_WEIGHT_DEMI + Demi = 7, + /// + /// DWRITE_PANOSE_WEIGHT_BOLD + Bold = 8, + /// + /// DWRITE_PANOSE_WEIGHT_HEAVY + Heavy = 9, + /// + /// DWRITE_PANOSE_WEIGHT_BLACK + Black = 10, + /// + /// DWRITE_PANOSE_WEIGHT_EXTRA_BLACK + ExtraBlack = 11, + /// + /// DWRITE_PANOSE_WEIGHT_NORD + Nord = 11, +} + +/// +/// DWRITE_PANOSE_PROPORTION +public enum PanoseProportion : int +{ + /// + /// DWRITE_PANOSE_PROPORTION_ANY + Any = 0, + /// + /// DWRITE_PANOSE_PROPORTION_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_PROPORTION_OLD_STYLE + OldStyle = 2, + /// + /// DWRITE_PANOSE_PROPORTION_MODERN + Modern = 3, + /// + /// DWRITE_PANOSE_PROPORTION_EVEN_WIDTH + EvenWidth = 4, + /// + /// DWRITE_PANOSE_PROPORTION_EXPANDED + Expanded = 5, + /// + /// DWRITE_PANOSE_PROPORTION_CONDENSED + Condensed = 6, + /// + /// DWRITE_PANOSE_PROPORTION_VERY_EXPANDED + VeryExpanded = 7, + /// + /// DWRITE_PANOSE_PROPORTION_VERY_CONDENSED + VeryCondensed = 8, + /// + /// DWRITE_PANOSE_PROPORTION_MONOSPACED + Monospaced = 9, +} + +/// +/// DWRITE_PANOSE_CONTRAST +public enum PanoseContrast : int +{ + /// + /// DWRITE_PANOSE_CONTRAST_ANY + Any = 0, + /// + /// DWRITE_PANOSE_CONTRAST_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_CONTRAST_NONE + None = 2, + /// + /// DWRITE_PANOSE_CONTRAST_VERY_LOW + VeryLow = 3, + /// + /// DWRITE_PANOSE_CONTRAST_LOW + Low = 4, + /// + /// DWRITE_PANOSE_CONTRAST_MEDIUM_LOW + MediumLow = 5, + /// + /// DWRITE_PANOSE_CONTRAST_MEDIUM + Medium = 6, + /// + /// DWRITE_PANOSE_CONTRAST_MEDIUM_HIGH + MediumHigh = 7, + /// + /// DWRITE_PANOSE_CONTRAST_HIGH + High = 8, + /// + /// DWRITE_PANOSE_CONTRAST_VERY_HIGH + VeryHigh = 9, + /// + /// DWRITE_PANOSE_CONTRAST_HORIZONTAL_LOW + HorizontalLow = 10, + /// + /// DWRITE_PANOSE_CONTRAST_HORIZONTAL_MEDIUM + HorizontalMedium = 11, + /// + /// DWRITE_PANOSE_CONTRAST_HORIZONTAL_HIGH + HorizontalHigh = 12, + /// + /// DWRITE_PANOSE_CONTRAST_BROKEN + Broken = 13, +} + +/// +/// DWRITE_PANOSE_STROKE_VARIATION +public enum PanoseStrokeVariation : int +{ + /// + /// DWRITE_PANOSE_STROKE_VARIATION_ANY + Any = 0, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_NO_VARIATION + NoVariation = 2, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_DIAGONAL + GradualDiagonal = 3, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_TRANSITIONAL + GradualTransitional = 4, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_VERTICAL + GradualVertical = 5, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_GRADUAL_HORIZONTAL + GradualHorizontal = 6, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_RAPID_VERTICAL + RapidVertical = 7, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_RAPID_HORIZONTAL + RapidHorizontal = 8, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_INSTANT_VERTICAL + InstantVertical = 9, + /// + /// DWRITE_PANOSE_STROKE_VARIATION_INSTANT_HORIZONTAL + InstantHorizontal = 10, +} + +/// +/// DWRITE_PANOSE_ARM_STYLE +public enum PanoseArmStyle : int +{ + /// + /// DWRITE_PANOSE_ARM_STYLE_ANY + Any = 0, + /// + /// DWRITE_PANOSE_ARM_STYLE_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_HORIZONTAL + StraightArmsHorizontal = 2, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_WEDGE + StraightArmsWedge = 3, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_VERTICAL + StraightArmsVertical = 4, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_SINGLE_SERIF + StraightArmsSingleSerif = 5, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_DOUBLE_SERIF + StraightArmsDoubleSerif = 6, + /// + /// DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_HORIZONTAL + NonstraightArmsHorizontal = 7, + /// + /// DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_WEDGE + NonstraightArmsWedge = 8, + /// + /// DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_VERTICAL + NonstraightArmsVertical = 9, + /// + /// DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_SINGLE_SERIF + NonstraightArmsSingleSerif = 10, + /// + /// DWRITE_PANOSE_ARM_STYLE_NONSTRAIGHT_ARMS_DOUBLE_SERIF + NonstraightArmsDoubleSerif = 11, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_HORZ + StraightArmsHorz = 2, + /// + /// DWRITE_PANOSE_ARM_STYLE_STRAIGHT_ARMS_VERT + StraightArmsVert = 4, + /// + /// DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_HORZ + BentArmsHorz = 7, + /// + /// DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_WEDGE + BentArmsWedge = 8, + /// + /// DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_VERT + BentArmsVert = 9, + /// + /// DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_SINGLE_SERIF + BentArmsSingleSerif = 10, + /// + /// DWRITE_PANOSE_ARM_STYLE_BENT_ARMS_DOUBLE_SERIF + BentArmsDoubleSerif = 11, +} + +/// +/// DWRITE_PANOSE_LETTERFORM +public enum PanoseLetterform : int +{ + /// + /// DWRITE_PANOSE_LETTERFORM_ANY + Any = 0, + /// + /// DWRITE_PANOSE_LETTERFORM_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_CONTACT + NormalContact = 2, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_WEIGHTED + NormalWeighted = 3, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_BOXED + NormalBoxed = 4, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_FLATTENED + NormalFlattened = 5, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_ROUNDED + NormalRounded = 6, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_OFF_CENTER + NormalOffCenter = 7, + /// + /// DWRITE_PANOSE_LETTERFORM_NORMAL_SQUARE + NormalSquare = 8, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_CONTACT + ObliqueContact = 9, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_WEIGHTED + ObliqueWeighted = 10, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_BOXED + ObliqueBoxed = 11, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_FLATTENED + ObliqueFlattened = 12, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_ROUNDED + ObliqueRounded = 13, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_OFF_CENTER + ObliqueOffCenter = 14, + /// + /// DWRITE_PANOSE_LETTERFORM_OBLIQUE_SQUARE + ObliqueSquare = 15, +} + +/// +/// DWRITE_PANOSE_MIDLINE +public enum PanoseMidline : int +{ + /// + /// DWRITE_PANOSE_MIDLINE_ANY + Any = 0, + /// + /// DWRITE_PANOSE_MIDLINE_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_MIDLINE_STANDARD_TRIMMED + StandardTrimmed = 2, + /// + /// DWRITE_PANOSE_MIDLINE_STANDARD_POINTED + StandardPointed = 3, + /// + /// DWRITE_PANOSE_MIDLINE_STANDARD_SERIFED + StandardSerifed = 4, + /// + /// DWRITE_PANOSE_MIDLINE_HIGH_TRIMMED + HighTrimmed = 5, + /// + /// DWRITE_PANOSE_MIDLINE_HIGH_POINTED + HighPointed = 6, + /// + /// DWRITE_PANOSE_MIDLINE_HIGH_SERIFED + HighSerifed = 7, + /// + /// DWRITE_PANOSE_MIDLINE_CONSTANT_TRIMMED + ConstantTrimmed = 8, + /// + /// DWRITE_PANOSE_MIDLINE_CONSTANT_POINTED + ConstantPointed = 9, + /// + /// DWRITE_PANOSE_MIDLINE_CONSTANT_SERIFED + ConstantSerifed = 10, + /// + /// DWRITE_PANOSE_MIDLINE_LOW_TRIMMED + LowTrimmed = 11, + /// + /// DWRITE_PANOSE_MIDLINE_LOW_POINTED + LowPointed = 12, + /// + /// DWRITE_PANOSE_MIDLINE_LOW_SERIFED + LowSerifed = 13, +} + +/// +/// DWRITE_PANOSE_XHEIGHT +public enum PanoseXheight : int +{ + /// + /// DWRITE_PANOSE_XHEIGHT_ANY + Any = 0, + /// + /// DWRITE_PANOSE_XHEIGHT_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_XHEIGHT_CONSTANT_SMALL + ConstantSmall = 2, + /// + /// DWRITE_PANOSE_XHEIGHT_CONSTANT_STANDARD + ConstantStandard = 3, + /// + /// DWRITE_PANOSE_XHEIGHT_CONSTANT_LARGE + ConstantLarge = 4, + /// + /// DWRITE_PANOSE_XHEIGHT_DUCKING_SMALL + DuckingSmall = 5, + /// + /// DWRITE_PANOSE_XHEIGHT_DUCKING_STANDARD + DuckingStandard = 6, + /// + /// DWRITE_PANOSE_XHEIGHT_DUCKING_LARGE + DuckingLarge = 7, + /// + /// DWRITE_PANOSE_XHEIGHT_CONSTANT_STD + ConstantStd = 3, + /// + /// DWRITE_PANOSE_XHEIGHT_DUCKING_STD + DuckingStd = 6, +} + +/// +/// DWRITE_PANOSE_TOOL_KIND +public enum PanoseToolKind : int +{ + /// + /// DWRITE_PANOSE_TOOL_KIND_ANY + Any = 0, + /// + /// DWRITE_PANOSE_TOOL_KIND_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_TOOL_KIND_FLAT_NIB + FlatNib = 2, + /// + /// DWRITE_PANOSE_TOOL_KIND_PRESSURE_POINT + PressurePoint = 3, + /// + /// DWRITE_PANOSE_TOOL_KIND_ENGRAVED + Engraved = 4, + /// + /// DWRITE_PANOSE_TOOL_KIND_BALL + Ball = 5, + /// + /// DWRITE_PANOSE_TOOL_KIND_BRUSH + Brush = 6, + /// + /// DWRITE_PANOSE_TOOL_KIND_ROUGH + Rough = 7, + /// + /// DWRITE_PANOSE_TOOL_KIND_FELT_PEN_BRUSH_TIP + FeltPenBrushTip = 8, + /// + /// DWRITE_PANOSE_TOOL_KIND_WILD_BRUSH + WildBrush = 9, +} + +/// +/// DWRITE_PANOSE_SPACING +public enum PanoseSpacing : int +{ + /// + /// DWRITE_PANOSE_SPACING_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SPACING_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SPACING_PROPORTIONAL_SPACED + ProportionalSpaced = 2, + /// + /// DWRITE_PANOSE_SPACING_MONOSPACED + Monospaced = 3, +} + +/// +/// DWRITE_PANOSE_ASPECT_RATIO +public enum PanoseAspectRatio : int +{ + /// + /// DWRITE_PANOSE_ASPECT_RATIO_ANY + Any = 0, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_VERY_CONDENSED + VeryCondensed = 2, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_CONDENSED + Condensed = 3, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_NORMAL + Normal = 4, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_EXPANDED + Expanded = 5, + /// + /// DWRITE_PANOSE_ASPECT_RATIO_VERY_EXPANDED + VeryExpanded = 6, +} + +/// +/// DWRITE_PANOSE_SCRIPT_TOPOLOGY +public enum PanoseScriptTopology : int +{ + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_DISCONNECTED + RomanDisconnected = 2, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_TRAILING + RomanTrailing = 3, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_ROMAN_CONNECTED + RomanConnected = 4, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_DISCONNECTED + CursiveDisconnected = 5, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_TRAILING + CursiveTrailing = 6, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_CURSIVE_CONNECTED + CursiveConnected = 7, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_DISCONNECTED + BlackletterDisconnected = 8, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_TRAILING + BlackletterTrailing = 9, + /// + /// DWRITE_PANOSE_SCRIPT_TOPOLOGY_BLACKLETTER_CONNECTED + BlackletterConnected = 10, +} + +/// +/// DWRITE_PANOSE_SCRIPT_FORM +public enum PanoseScriptForm : int +{ + /// + /// DWRITE_PANOSE_SCRIPT_FORM_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_NO_WRAPPING + UprightNoWrapping = 2, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_SOME_WRAPPING + UprightSomeWrapping = 3, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_MORE_WRAPPING + UprightMoreWrapping = 4, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_UPRIGHT_EXTREME_WRAPPING + UprightExtremeWrapping = 5, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_NO_WRAPPING + ObliqueNoWrapping = 6, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_SOME_WRAPPING + ObliqueSomeWrapping = 7, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_MORE_WRAPPING + ObliqueMoreWrapping = 8, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_OBLIQUE_EXTREME_WRAPPING + ObliqueExtremeWrapping = 9, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_NO_WRAPPING + ExaggeratedNoWrapping = 10, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_SOME_WRAPPING + ExaggeratedSomeWrapping = 11, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_MORE_WRAPPING + ExaggeratedMoreWrapping = 12, + /// + /// DWRITE_PANOSE_SCRIPT_FORM_EXAGGERATED_EXTREME_WRAPPING + ExaggeratedExtremeWrapping = 13, +} + +/// +/// DWRITE_PANOSE_FINIALS +public enum PanoseFinials : int +{ + /// + /// DWRITE_PANOSE_FINIALS_ANY + Any = 0, + /// + /// DWRITE_PANOSE_FINIALS_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_FINIALS_NONE_NO_LOOPS + NoneNoLoops = 2, + /// + /// DWRITE_PANOSE_FINIALS_NONE_CLOSED_LOOPS + NoneClosedLoops = 3, + /// + /// DWRITE_PANOSE_FINIALS_NONE_OPEN_LOOPS + NoneOpenLoops = 4, + /// + /// DWRITE_PANOSE_FINIALS_SHARP_NO_LOOPS + SharpNoLoops = 5, + /// + /// DWRITE_PANOSE_FINIALS_SHARP_CLOSED_LOOPS + SharpClosedLoops = 6, + /// + /// DWRITE_PANOSE_FINIALS_SHARP_OPEN_LOOPS + SharpOpenLoops = 7, + /// + /// DWRITE_PANOSE_FINIALS_TAPERED_NO_LOOPS + TaperedNoLoops = 8, + /// + /// DWRITE_PANOSE_FINIALS_TAPERED_CLOSED_LOOPS + TaperedClosedLoops = 9, + /// + /// DWRITE_PANOSE_FINIALS_TAPERED_OPEN_LOOPS + TaperedOpenLoops = 10, + /// + /// DWRITE_PANOSE_FINIALS_ROUND_NO_LOOPS + RoundNoLoops = 11, + /// + /// DWRITE_PANOSE_FINIALS_ROUND_CLOSED_LOOPS + RoundClosedLoops = 12, + /// + /// DWRITE_PANOSE_FINIALS_ROUND_OPEN_LOOPS + RoundOpenLoops = 13, +} + +/// +/// DWRITE_PANOSE_XASCENT +public enum PanoseXascent : int +{ + /// + /// DWRITE_PANOSE_XASCENT_ANY + Any = 0, + /// + /// DWRITE_PANOSE_XASCENT_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_XASCENT_VERY_LOW + VeryLow = 2, + /// + /// DWRITE_PANOSE_XASCENT_LOW + Low = 3, + /// + /// DWRITE_PANOSE_XASCENT_MEDIUM + Medium = 4, + /// + /// DWRITE_PANOSE_XASCENT_HIGH + High = 5, + /// + /// DWRITE_PANOSE_XASCENT_VERY_HIGH + VeryHigh = 6, +} + +/// +/// DWRITE_PANOSE_DECORATIVE_CLASS +public enum PanoseDecorativeClass : int +{ + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_ANY + Any = 0, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_DERIVATIVE + Derivative = 2, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_TOPOLOGY + NonstandardTopology = 3, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_ELEMENTS + NonstandardElements = 4, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_NONSTANDARD_ASPECT + NonstandardAspect = 5, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_INITIALS + Initials = 6, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_CARTOON + Cartoon = 7, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_PICTURE_STEMS + PictureStems = 8, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_ORNAMENTED + Ornamented = 9, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_TEXT_AND_BACKGROUND + TextAndBackground = 10, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_COLLAGE + Collage = 11, + /// + /// DWRITE_PANOSE_DECORATIVE_CLASS_MONTAGE + Montage = 12, +} + +/// +/// DWRITE_PANOSE_ASPECT +public enum PanoseAspect : int +{ + /// + /// DWRITE_PANOSE_ASPECT_ANY + Any = 0, + /// + /// DWRITE_PANOSE_ASPECT_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_ASPECT_SUPER_CONDENSED + SuperCondensed = 2, + /// + /// DWRITE_PANOSE_ASPECT_VERY_CONDENSED + VeryCondensed = 3, + /// + /// DWRITE_PANOSE_ASPECT_CONDENSED + Condensed = 4, + /// + /// DWRITE_PANOSE_ASPECT_NORMAL + Normal = 5, + /// + /// DWRITE_PANOSE_ASPECT_EXTENDED + Extended = 6, + /// + /// DWRITE_PANOSE_ASPECT_VERY_EXTENDED + VeryExtended = 7, + /// + /// DWRITE_PANOSE_ASPECT_SUPER_EXTENDED + SuperExtended = 8, + /// + /// DWRITE_PANOSE_ASPECT_MONOSPACED + Monospaced = 9, +} + +/// +/// DWRITE_PANOSE_FILL +public enum PanoseFill : int +{ + /// + /// DWRITE_PANOSE_FILL_ANY + Any = 0, + /// + /// DWRITE_PANOSE_FILL_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_FILL_STANDARD_SOLID_FILL + StandardSolidFill = 2, + /// + /// DWRITE_PANOSE_FILL_NO_FILL + NoFill = 3, + /// + /// DWRITE_PANOSE_FILL_PATTERNED_FILL + PatternedFill = 4, + /// + /// DWRITE_PANOSE_FILL_COMPLEX_FILL + ComplexFill = 5, + /// + /// DWRITE_PANOSE_FILL_SHAPED_FILL + ShapedFill = 6, + /// + /// DWRITE_PANOSE_FILL_DRAWN_DISTRESSED + DrawnDistressed = 7, +} + +/// +/// DWRITE_PANOSE_LINING +public enum PanoseLining : int +{ + /// + /// DWRITE_PANOSE_LINING_ANY + Any = 0, + /// + /// DWRITE_PANOSE_LINING_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_LINING_NONE + None = 2, + /// + /// DWRITE_PANOSE_LINING_INLINE + Inline = 3, + /// + /// DWRITE_PANOSE_LINING_OUTLINE + Outline = 4, + /// + /// DWRITE_PANOSE_LINING_ENGRAVED + Engraved = 5, + /// + /// DWRITE_PANOSE_LINING_SHADOW + Shadow = 6, + /// + /// DWRITE_PANOSE_LINING_RELIEF + Relief = 7, + /// + /// DWRITE_PANOSE_LINING_BACKDROP + Backdrop = 8, +} + +/// +/// DWRITE_PANOSE_DECORATIVE_TOPOLOGY +public enum PanoseDecorativeTopology : int +{ + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_ANY + Any = 0, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_STANDARD + Standard = 2, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_SQUARE + Square = 3, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_MULTIPLE_SEGMENT + MultipleSegment = 4, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_ART_DECO + ArtDeco = 5, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_UNEVEN_WEIGHTING + UnevenWeighting = 6, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_DIVERSE_ARMS + DiverseArms = 7, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_DIVERSE_FORMS + DiverseForms = 8, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_LOMBARDIC_FORMS + LombardicForms = 9, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_UPPER_CASE_IN_LOWER_CASE + UpperCaseInLowerCase = 10, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_IMPLIED_TOPOLOGY + ImpliedTopology = 11, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_HORSESHOE_E_AND_A + HorseshoeEAndA = 12, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_CURSIVE + Cursive = 13, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_BLACKLETTER + Blackletter = 14, + /// + /// DWRITE_PANOSE_DECORATIVE_TOPOLOGY_SWASH_VARIANCE + SwashVariance = 15, +} + +/// +/// DWRITE_PANOSE_CHARACTER_RANGES +public enum PanoseCharacterRanges : int +{ + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_ANY + Any = 0, + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_EXTENDED_COLLECTION + ExtendedCollection = 2, + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_LITERALS + Literals = 3, + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_NO_LOWER_CASE + NoLowerCase = 4, + /// + /// DWRITE_PANOSE_CHARACTER_RANGES_SMALL_CAPS + SmallCaps = 5, +} + +/// +/// DWRITE_PANOSE_SYMBOL_KIND +public enum PanoseSymbolKind : int +{ + /// + /// DWRITE_PANOSE_SYMBOL_KIND_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_MONTAGES + Montages = 2, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_PICTURES + Pictures = 3, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_SHAPES + Shapes = 4, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_SCIENTIFIC + Scientific = 5, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_MUSIC + Music = 6, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_EXPERT + Expert = 7, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_PATTERNS + Patterns = 8, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_BOARDERS + Boarders = 9, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_ICONS + Icons = 10, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_LOGOS + Logos = 11, + /// + /// DWRITE_PANOSE_SYMBOL_KIND_INDUSTRY_SPECIFIC + IndustrySpecific = 12, +} + +/// +/// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO +public enum PanoseSymbolAspectRatio : int +{ + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_ANY + Any = 0, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NO_FIT + NoFit = 1, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NO_WIDTH + NoWidth = 2, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_EXCEPTIONALLY_WIDE + ExceptionallyWide = 3, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_SUPER_WIDE + SuperWide = 4, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_VERY_WIDE + VeryWide = 5, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_WIDE + Wide = 6, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NORMAL + Normal = 7, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_NARROW + Narrow = 8, + /// + /// DWRITE_PANOSE_SYMBOL_ASPECT_RATIO_VERY_NARROW + VeryNarrow = 9, +} + +/// +/// DWRITE_OUTLINE_THRESHOLD +public enum OutlineThreshold : int +{ + /// + /// DWRITE_OUTLINE_THRESHOLD_ANTIALIASED + Antialiased = 0, + /// + /// DWRITE_OUTLINE_THRESHOLD_ALIASED + Aliased = 1, +} + +/// +/// DWRITE_BASELINE +public enum Baseline : int +{ + /// + /// DWRITE_BASELINE_DEFAULT + Default = 0, + /// + /// DWRITE_BASELINE_ROMAN + Roman = 1, + /// + /// DWRITE_BASELINE_CENTRAL + Central = 2, + /// + /// DWRITE_BASELINE_MATH + Math = 3, + /// + /// DWRITE_BASELINE_HANGING + Hanging = 4, + /// + /// DWRITE_BASELINE_IDEOGRAPHIC_BOTTOM + IdeographicBottom = 5, + /// + /// DWRITE_BASELINE_IDEOGRAPHIC_TOP + IdeographicTop = 6, + /// + /// DWRITE_BASELINE_MINIMUM + Minimum = 7, + /// + /// DWRITE_BASELINE_MAXIMUM + Maximum = 8, +} + +/// +/// DWRITE_VERTICAL_GLYPH_ORIENTATION +public enum VerticalGlyphOrientation : int +{ + /// + /// DWRITE_VERTICAL_GLYPH_ORIENTATION_DEFAULT + Default = 0, + /// + /// DWRITE_VERTICAL_GLYPH_ORIENTATION_STACKED + Stacked = 1, +} + +/// +/// DWRITE_GLYPH_ORIENTATION_ANGLE +public enum GlyphOrientationAngle : int +{ + /// + /// DWRITE_GLYPH_ORIENTATION_ANGLE_0_DEGREES + _0Degrees = 0, + /// + /// DWRITE_GLYPH_ORIENTATION_ANGLE_90_DEGREES + _90Degrees = 1, + /// + /// DWRITE_GLYPH_ORIENTATION_ANGLE_180_DEGREES + _180Degrees = 2, + /// + /// DWRITE_GLYPH_ORIENTATION_ANGLE_270_DEGREES + _270Degrees = 3, +} + +/// +/// DWRITE_TEXT_ANTIALIAS_MODE +public enum TextAntialiasMode : int +{ + /// + /// DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE + Cleartype = 0, + /// + /// DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE + Grayscale = 1, +} + +/// +/// DWRITE_OPTICAL_ALIGNMENT +public enum OpticalAlignment : int +{ + /// + /// DWRITE_OPTICAL_ALIGNMENT_NONE + None = 0, + /// + /// DWRITE_OPTICAL_ALIGNMENT_NO_SIDE_BEARINGS + NoSideBearings = 1, +} + +/// +/// DWRITE_GRID_FIT_MODE +public enum GridFitMode : int +{ + /// + /// DWRITE_GRID_FIT_MODE_DEFAULT + Default = 0, + /// + /// DWRITE_GRID_FIT_MODE_DISABLED + Disabled = 1, + /// + /// DWRITE_GRID_FIT_MODE_ENABLED + Enabled = 2, +} + +/// +/// DWRITE_FONT_PROPERTY_ID +public enum FontPropertyId : int +{ + /// + /// DWRITE_FONT_PROPERTY_ID_NONE + None = 0, + /// + /// DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FAMILY_NAME + WeightStretchStyleFamilyName = 1, + /// + /// DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FAMILY_NAME + TypographicFamilyName = 2, + /// + /// DWRITE_FONT_PROPERTY_ID_WEIGHT_STRETCH_STYLE_FACE_NAME + WeightStretchStyleFaceName = 3, + /// + /// DWRITE_FONT_PROPERTY_ID_FULL_NAME + FullName = 4, + /// + /// DWRITE_FONT_PROPERTY_ID_WIN32_FAMILY_NAME + Win32FamilyName = 5, + /// + /// DWRITE_FONT_PROPERTY_ID_POSTSCRIPT_NAME + PostscriptName = 6, + /// + /// DWRITE_FONT_PROPERTY_ID_DESIGN_SCRIPT_LANGUAGE_TAG + DesignScriptLanguageTag = 7, + /// + /// DWRITE_FONT_PROPERTY_ID_SUPPORTED_SCRIPT_LANGUAGE_TAG + SupportedScriptLanguageTag = 8, + /// + /// DWRITE_FONT_PROPERTY_ID_SEMANTIC_TAG + SemanticTag = 9, + /// + /// DWRITE_FONT_PROPERTY_ID_WEIGHT + Weight = 10, + /// + /// DWRITE_FONT_PROPERTY_ID_STRETCH + Stretch = 11, + /// + /// DWRITE_FONT_PROPERTY_ID_STYLE + Style = 12, + /// + /// DWRITE_FONT_PROPERTY_ID_TYPOGRAPHIC_FACE_NAME + TypographicFaceName = 13, + /// + /// DWRITE_FONT_PROPERTY_ID_TOTAL + Total = 13, + /// + /// DWRITE_FONT_PROPERTY_ID_TOTAL_RS3 + TotalRs3 = 14, + /// + /// DWRITE_FONT_PROPERTY_ID_PREFERRED_FAMILY_NAME + PreferredFamilyName = 2, + /// + /// DWRITE_FONT_PROPERTY_ID_FAMILY_NAME + FamilyName = 1, + /// + /// DWRITE_FONT_PROPERTY_ID_FACE_NAME + FaceName = 3, +} + +/// +/// DWRITE_LOCALITY +public enum Locality : int +{ + /// + /// DWRITE_LOCALITY_REMOTE + Remote = 0, + /// + /// DWRITE_LOCALITY_PARTIAL + Partial = 1, + /// + /// DWRITE_LOCALITY_LOCAL + Local = 2, +} + +/// +/// DWRITE_RENDERING_MODE1 +public enum RenderingMode1 : int +{ + /// + /// DWRITE_RENDERING_MODE1_DEFAULT + Default = 0, + /// + /// DWRITE_RENDERING_MODE1_ALIASED + Aliased = 1, + /// + /// DWRITE_RENDERING_MODE1_GDI_CLASSIC + GDIClassic = 2, + /// + /// DWRITE_RENDERING_MODE1_GDI_NATURAL + GDINatural = 3, + /// + /// DWRITE_RENDERING_MODE1_NATURAL + Natural = 4, + /// + /// DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC + NaturalSymmetric = 5, + /// + /// DWRITE_RENDERING_MODE1_OUTLINE + Outline = 6, + /// + /// DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC_DOWNSAMPLED + NaturalSymmetricDownsampled = 7, +} + +/// +/// DWRITE_FONT_LINE_GAP_USAGE +public enum FontLineGapUsage : int +{ + /// + /// DWRITE_FONT_LINE_GAP_USAGE_DEFAULT + Default = 0, + /// + /// DWRITE_FONT_LINE_GAP_USAGE_DISABLED + Disabled = 1, + /// + /// DWRITE_FONT_LINE_GAP_USAGE_ENABLED + Enabled = 2, +} + +/// +/// DWRITE_CONTAINER_TYPE +public enum ContainerType : int +{ + /// + /// DWRITE_CONTAINER_TYPE_UNKNOWN + Unknown = 0, + /// + /// DWRITE_CONTAINER_TYPE_WOFF + Woff = 1, + /// + /// DWRITE_CONTAINER_TYPE_WOFF2 + Woff2 = 2, +} + +/// +/// DWRITE_FONT_FAMILY_MODEL +public enum FontFamilyModel : int +{ + /// + /// DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC + Typographic = 0, + /// + /// DWRITE_FONT_FAMILY_MODEL_WEIGHT_STRETCH_STYLE + WeightStretchStyle = 1, +} + +/// +/// DWRITE_AUTOMATIC_FONT_AXES +[Flags] +public enum AutomaticFontAxes : uint +{ + /// + /// DWRITE_AUTOMATIC_FONT_AXES_NONE + None = 0, + /// + /// DWRITE_AUTOMATIC_FONT_AXES_OPTICAL_SIZE + OpticalSize = 1, +} + +/// +/// DWRITE_FONT_AXIS_ATTRIBUTES +[Flags] +public enum FontAxisAttributes : uint +{ + /// + /// DWRITE_FONT_AXIS_ATTRIBUTES_NONE + None = 0, + /// + /// DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE + Variable = 1, + /// + /// DWRITE_FONT_AXIS_ATTRIBUTES_HIDDEN + Hidden = 2, +} + +/// +/// DWRITE_FONT_SOURCE_TYPE +public enum FontSourceType : int +{ + /// + /// DWRITE_FONT_SOURCE_TYPE_UNKNOWN + Unknown = 0, + /// + /// DWRITE_FONT_SOURCE_TYPE_PER_MACHINE + PerMachine = 1, + /// + /// DWRITE_FONT_SOURCE_TYPE_PER_USER + PerUser = 2, + /// + /// DWRITE_FONT_SOURCE_TYPE_APPX_PACKAGE + AppxPackage = 3, + /// + /// DWRITE_FONT_SOURCE_TYPE_REMOTE_FONT_PROVIDER + RemoteFontProvider = 4, +} + +#endregion Enums + +#region Unions +/// +/// DWRITE_PANOSE +[StructLayout(LayoutKind.Explicit)] +public partial struct Panose +{ + /// + [FieldOffset(0)] + public unsafe fixed byte values[10]; + + /// + [FieldOffset(0)] + public byte familyKind; + + /// + [FieldOffset(0)] + public _text_e__Struct text; + + /// + [FieldOffset(0)] + public _script_e__Struct script; + + /// + [FieldOffset(0)] + public _decorative_e__Struct decorative; + + /// + [FieldOffset(0)] + public _symbol_e__Struct symbol; + + public partial struct _decorative_e__Struct + { + /// + public byte familyKind; + + /// + public byte decorativeClass; + + /// + public byte weight; + + /// + public byte aspect; + + /// + public byte contrast; + + /// + public byte serifVariant; + + /// + public byte fill; + + /// + public byte lining; + + /// + public byte decorativeTopology; + + /// + public byte characterRange; + } + + public partial struct _text_e__Struct + { + /// + public byte familyKind; + + /// + public byte serifStyle; + + /// + public byte weight; + + /// + public byte proportion; + + /// + public byte contrast; + + /// + public byte strokeVariation; + + /// + public byte armStyle; + + /// + public byte letterform; + + /// + public byte midline; + + /// + public byte xHeight; + } + + public partial struct _symbol_e__Struct + { + /// + public byte familyKind; + + /// + public byte symbolKind; + + /// + public byte weight; + + /// + public byte spacing; + + /// + public byte aspectRatioAndContrast; + + /// + public byte aspectRatio94; + + /// + public byte aspectRatio119; + + /// + public byte aspectRatio157; + + /// + public byte aspectRatio163; + + /// + public byte aspectRatio211; + } + + public partial struct _script_e__Struct + { + /// + public byte familyKind; + + /// + public byte toolKind; + + /// + public byte weight; + + /// + public byte spacing; + + /// + public byte aspectRatio; + + /// + public byte contrast; + + /// + public byte scriptTopology; + + /// + public byte scriptForm; + + /// + public byte finials; + + /// + public byte xAscent; + } + +} + +#endregion Unions + +#region Structs +/// +/// DWRITE_COLOR_F +public partial struct ColorF +{ + /// + public float r; + + /// + public float g; + + /// + public float b; + + /// + public float a; +} + +/// +/// DWRITE_FONT_METRICS +public partial struct FontMetrics +{ + /// + public ushort designUnitsPerEm; + + /// + public ushort ascent; + + /// + public ushort descent; + + /// + public short lineGap; + + /// + public ushort capHeight; + + /// + public ushort xHeight; + + /// + public short underlinePosition; + + /// + public ushort underlineThickness; + + /// + public short strikethroughPosition; + + /// + public ushort strikethroughThickness; +} + +/// +/// DWRITE_GLYPH_METRICS +public partial struct GlyphMetrics +{ + /// + public int leftSideBearing; + + /// + public uint advanceWidth; + + /// + public int rightSideBearing; + + /// + public int topSideBearing; + + /// + public uint advanceHeight; + + /// + public int bottomSideBearing; + + /// + public int verticalOriginY; +} + +/// +/// DWRITE_GLYPH_OFFSET +public partial struct GlyphOffset +{ + /// + public float advanceOffset; + + /// + public float ascenderOffset; +} + +/// +/// DWRITE_MATRIX +public partial struct Matrix +{ + /// + public float m11; + + /// + public float m12; + + /// + public float m21; + + /// + public float m22; + + /// + public float dx; + + /// + public float dy; +} + +/// +/// DWRITE_TEXT_RANGE +public partial struct TextRange +{ + /// + public uint startPosition; + + /// + public uint length; +} + +/// +/// DWRITE_FONT_FEATURE +public partial struct FontFeature +{ + /// + public FontFeatureTag nameTag; + + /// + public uint parameter; +} + +/// +/// DWRITE_TYPOGRAPHIC_FEATURES +public partial struct TypographicFeatures +{ + /// + public unsafe FontFeature* features; + + /// + public uint featureCount; +} + +/// +/// DWRITE_TRIMMING +public partial struct Trimming +{ + /// + public TrimmingGranularity granularity; + + /// + public uint delimiter; + + /// + public uint delimiterCount; +} + +/// +/// DWRITE_SCRIPT_ANALYSIS +public partial struct ScriptAnalysis +{ + /// + public ushort script; + + /// + public ScriptShapes shapes; +} + +/// +/// DWRITE_LINE_BREAKPOINT +public partial struct LineBreakpoint +{ + /// + public byte _bitfield; +} + +/// +/// DWRITE_SHAPING_TEXT_PROPERTIES +public partial struct ShapingTextProperties +{ + /// + public ushort _bitfield; +} + +/// +/// DWRITE_SHAPING_GLYPH_PROPERTIES +public partial struct ShapingGlyphProperties +{ + /// + public ushort _bitfield; +} + +/// +/// DWRITE_GLYPH_RUN +public partial struct GlyphRun +{ + /// + public IDWriteFontFace fontFace; + + /// + public float fontEmSize; + + /// + public uint glyphCount; + + /// + public unsafe ushort* glyphIndices; + + /// + public unsafe float* glyphAdvances; + + /// + public unsafe GlyphOffset* glyphOffsets; + + /// + public Bool32 isSideways; + + /// + public uint bidiLevel; +} + +/// +/// DWRITE_GLYPH_RUN_DESCRIPTION +public partial struct GlyphRunDescription +{ + /// + public unsafe ushort* localeName; + + /// + public unsafe ushort* @string; + + /// + public uint stringLength; + + /// + public unsafe ushort* clusterMap; + + /// + public uint textPosition; +} + +/// +/// DWRITE_UNDERLINE +public partial struct Underline +{ + /// + public float width; + + /// + public float thickness; + + /// + public float offset; + + /// + public float runHeight; + + /// + public ReadingDirection readingDirection; + + /// + public FlowDirection flowDirection; + + /// + public unsafe ushort* localeName; + + /// + public MeasuringMode measuringMode; +} + +/// +/// DWRITE_STRIKETHROUGH +public partial struct Strikethrough +{ + /// + public float width; + + /// + public float thickness; + + /// + public float offset; + + /// + public ReadingDirection readingDirection; + + /// + public FlowDirection flowDirection; + + /// + public unsafe ushort* localeName; + + /// + public MeasuringMode measuringMode; +} + +/// +/// DWRITE_LINE_METRICS +public partial struct LineMetrics +{ + /// + public uint length; + + /// + public uint trailingWhitespaceLength; + + /// + public uint newlineLength; + + /// + public float height; + + /// + public float baseline; + + /// + public Bool32 isTrimmed; +} + +/// +/// DWRITE_CLUSTER_METRICS +public partial struct ClusterMetrics +{ + /// + public float width; + + /// + public ushort length; + + /// + public ushort _bitfield; +} + +/// +/// DWRITE_TEXT_METRICS +public partial struct TextMetrics +{ + /// + public float left; + + /// + public float top; + + /// + public float width; + + /// + public float widthIncludingTrailingWhitespace; + + /// + public float height; + + /// + public float layoutWidth; + + /// + public float layoutHeight; + + /// + public uint maxBidiReorderingDepth; + + /// + public uint lineCount; +} + +/// +/// DWRITE_INLINE_OBJECT_METRICS +public partial struct InlineObjectMetrics +{ + /// + public float width; + + /// + public float height; + + /// + public float baseline; + + /// + public Bool32 supportsSideways; +} + +/// +/// DWRITE_OVERHANG_METRICS +public partial struct OverhangMetrics +{ + /// + public float left; + + /// + public float top; + + /// + public float right; + + /// + public float bottom; +} + +/// +/// DWRITE_HIT_TEST_METRICS +public partial struct HitTestMetrics +{ + /// + public uint textPosition; + + /// + public uint length; + + /// + public float left; + + /// + public float top; + + /// + public float width; + + /// + public float height; + + /// + public uint bidiLevel; + + /// + public Bool32 isText; + + /// + public Bool32 isTrimmed; +} + +/// +/// DWRITE_FONT_METRICS1 +public partial struct FontMetrics1 +{ + /// + public FontMetrics __AnonymousBase_DWrite_1_L627_C38; + + /// + public short glyphBoxLeft; + + /// + public short glyphBoxTop; + + /// + public short glyphBoxRight; + + /// + public short glyphBoxBottom; + + /// + public short subscriptPositionX; + + /// + public short subscriptPositionY; + + /// + public short subscriptSizeX; + + /// + public short subscriptSizeY; + + /// + public short superscriptPositionX; + + /// + public short superscriptPositionY; + + /// + public short superscriptSizeX; + + /// + public short superscriptSizeY; + + /// + public Bool32 hasTypographicMetrics; +} + +/// +/// DWRITE_CARET_METRICS +public partial struct CaretMetrics +{ + /// + public short slopeRise; + + /// + public short slopeRun; + + /// + public short offset; +} + +/// +/// DWRITE_UNICODE_RANGE +public partial struct UnicodeRange +{ + /// + public uint first; + + /// + public uint last; +} + +/// +/// DWRITE_SCRIPT_PROPERTIES +public partial struct ScriptProperties +{ + /// + public uint isoScriptCode; + + /// + public uint isoScriptNumber; + + /// + public uint clusterLookahead; + + /// + public uint justificationCharacter; + + /// + public uint _bitfield; +} + +/// +/// DWRITE_JUSTIFICATION_OPPORTUNITY +public partial struct JustificationOpportunity +{ + /// + public float expansionMinimum; + + /// + public float expansionMaximum; + + /// + public float compressionMaximum; + + /// + public uint _bitfield; +} + +/// +/// DWRITE_TEXT_METRICS1 +public partial struct TextMetrics1 +{ + /// + public TextMetrics Base; + + /// + public float heightIncludingTrailingWhitespace; +} + +/// +/// DWRITE_COLOR_GLYPH_RUN +public partial struct ColorGlyphRun +{ + /// + public GlyphRun glyphRun; + + /// + public unsafe GlyphRunDescription* glyphRunDescription; + + /// + public float baselineOriginX; + + /// + public float baselineOriginY; + + /// + public ColorF runColor; + + /// + public ushort paletteIndex; +} + +/// +/// DWRITE_FONT_PROPERTY +public partial struct FontProperty +{ + /// + public FontPropertyId propertyId; + + /// + public unsafe ushort* propertyValue; + + /// + public unsafe ushort* localeName; +} + +/// +/// DWRITE_LINE_METRICS1 +public partial struct LineMetrics1 +{ + /// + public LineMetrics Base; + + /// + public float leadingBefore; + + /// + public float leadingAfter; +} + +/// +/// DWRITE_LINE_SPACING +public partial struct LineSpacing +{ + /// + public LineSpacingMethod method; + + /// + public float height; + + /// + public float baseline; + + /// + public float leadingBefore; + + /// + public FontLineGapUsage fontLineGapUsage; +} + +/// +/// DWRITE_COLOR_GLYPH_RUN1 +public partial struct ColorGlyphRun1 +{ + /// + public ColorGlyphRun Base; + + /// + public GlyphImageFormats glyphImageFormat; + + /// + public MeasuringMode measuringMode; +} + +/// +/// DWRITE_GLYPH_IMAGE_DATA +public partial struct GlyphImageData +{ + /// + public unsafe void* imageData; + + /// + public uint imageDataSize; + + /// + public uint uniqueDataId; + + /// + public uint pixelsPerEm; + + /// + public Graphics.Direct2D.Common.SizeU pixelSize; + + /// + public System.Drawing.Point horizontalLeftOrigin; + + /// + public System.Drawing.Point horizontalRightOrigin; + + /// + public System.Drawing.Point verticalTopOrigin; + + /// + public System.Drawing.Point verticalBottomOrigin; +} + +/// +/// DWRITE_FILE_FRAGMENT +public partial struct FileFragment +{ + /// + public ulong fileOffset; + + /// + public ulong fragmentSize; +} + +/// +/// DWRITE_FONT_AXIS_VALUE +public partial struct FontAxisValue +{ + /// + public FontAxisTag axisTag; + + /// + public float value; +} + +/// +/// DWRITE_FONT_AXIS_RANGE +public partial struct FontAxisRange +{ + /// + public FontAxisTag axisTag; + + /// + public float minValue; + + /// + public float maxValue; +} + +#endregion Structs + +#region COM Types +/// +/// IDWriteFontFileLoader +[Guid("727cad4e-d6af-4c9e-8a08-d695b11caa49")] +[NativeTypeName("struct IDWriteFontFileLoader : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFileLoader +{ + public static ref readonly Guid IID_IDWriteFontFileLoader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4E, 0xAD, 0x7C, 0x72, + 0xAF, 0xD6, + 0x9E, 0x4C, + 0x8A, + 0x08, + 0xD6, + 0x95, + 0xB1, + 0x1C, + 0xAA, + 0x49 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFileLoader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateStreamFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileStream** fontFileStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileStream); + } +} + +/// +/// IDWriteLocalFontFileLoader +[Guid("b2d9f3ec-c9fe-4a11-a2ec-d86208f7c0a2")] +[NativeTypeName("struct IDWriteLocalFontFileLoader : IDWriteFontFileLoader")] +[NativeInheritance("IDWriteFontFileLoader")] +public unsafe partial struct IDWriteLocalFontFileLoader +{ + public static ref readonly Guid IID_IDWriteLocalFontFileLoader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEC, 0xF3, 0xD9, 0xB2, + 0xFE, 0xC9, + 0x11, 0x4A, + 0xA2, + 0xEC, + 0xD8, + 0x62, + 0x08, + 0xF7, + 0xC0, + 0xA2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteLocalFontFileLoader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateStreamFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileStream** fontFileStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteLocalFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFilePathLengthFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, uint* filePathLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteLocalFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, filePathLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFilePathFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, ushort* filePath, uint filePathSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteLocalFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, filePath, filePathSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLastWriteTimeFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, ulong* lastWriteTime) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteLocalFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, lastWriteTime); + } +} + +/// +/// IDWriteFontFileStream +[Guid("6d4865fe-0ab8-4d91-8f62-5dd6be34a3e0")] +[NativeTypeName("struct IDWriteFontFileStream : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFileStream +{ + public static ref readonly Guid IID_IDWriteFontFileStream + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFE, 0x65, 0x48, 0x6D, + 0xB8, 0x0A, + 0x91, 0x4D, + 0x8F, + 0x62, + 0x5D, + 0xD6, + 0xBE, + 0x34, + 0xA3, + 0xE0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFileStream)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult ReadFileFragment(void** fragmentStart, ulong fileOffset, ulong fragmentSize, void** fragmentContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFileStream*)Unsafe.AsPointer(ref this), fragmentStart, fileOffset, fragmentSize, fragmentContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ReleaseFileFragment(void* fragmentContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFileStream*)Unsafe.AsPointer(ref this), fragmentContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFileSize(ulong* fileSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFileStream*)Unsafe.AsPointer(ref this), fileSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLastWriteTime(ulong* lastWriteTime) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFileStream*)Unsafe.AsPointer(ref this), lastWriteTime); + } +} + +/// +/// IDWriteFontFile +[Guid("739d886a-cef5-47dc-8769-1a8b41bebbb0")] +[NativeTypeName("struct IDWriteFontFile : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFile +{ + public static ref readonly Guid IID_IDWriteFontFile + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x6A, 0x88, 0x9D, 0x73, + 0xF5, 0xCE, + 0xDC, 0x47, + 0x87, + 0x69, + 0x1A, + 0x8B, + 0x41, + 0xBE, + 0xBB, + 0xB0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFile)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetReferenceKey(void** fontFileReferenceKey, uint* fontFileReferenceKeySize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFile*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetLoader(IDWriteFontFileLoader** fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFile*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult Analyze(Bool32* isSupportedFontType, FontFileType* fontFileType, FontFaceType* fontFaceType, uint* numberOfFaces) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFile*)Unsafe.AsPointer(ref this), isSupportedFontType, fontFileType, fontFaceType, numberOfFaces); + } +} + +/// +/// IDWriteRenderingParams +[Guid("2f0da53a-2add-47cd-82ee-d9ec34688e75")] +[NativeTypeName("struct IDWriteRenderingParams : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteRenderingParams +{ + public static ref readonly Guid IID_IDWriteRenderingParams + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3A, 0xA5, 0x0D, 0x2F, + 0xDD, 0x2A, + 0xCD, 0x47, + 0x82, + 0xEE, + 0xD9, + 0xEC, + 0x34, + 0x68, + 0x8E, + 0x75 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRenderingParams)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public float GetGamma() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRenderingParams*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public float GetEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRenderingParams*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetClearTypeLevel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRenderingParams*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.PixelGeometry GetPixelGeometry() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRenderingParams*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.RenderingMode GetRenderingMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteRenderingParams*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFontFace +[Guid("5f49804d-7024-4d43-bfa9-d25984f53849")] +[NativeTypeName("struct IDWriteFontFace : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFace +{ + public static ref readonly Guid IID_IDWriteFontFace + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x4D, 0x80, 0x49, 0x5F, + 0x24, 0x70, + 0x43, 0x4D, + 0xBF, + 0xA9, + 0xD2, + 0x59, + 0x84, + 0xF5, + 0x38, + 0x49 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } +} + +/// +/// IDWriteFontCollectionLoader +[Guid("cca920e4-52f0-492b-bfa8-29c72ee0a468")] +[NativeTypeName("struct IDWriteFontCollectionLoader : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontCollectionLoader +{ + public static ref readonly Guid IID_IDWriteFontCollectionLoader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE4, 0x20, 0xA9, 0xCC, + 0xF0, 0x52, + 0x2B, 0x49, + 0xBF, + 0xA8, + 0x29, + 0xC7, + 0x2E, + 0xE0, + 0xA4, + 0x68 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontCollectionLoader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateEnumeratorFromKey(IDWriteFactory* factory, void* collectionKey, uint collectionKeySize, IDWriteFontFileEnumerator** fontFileEnumerator) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontCollectionLoader*)Unsafe.AsPointer(ref this), factory, collectionKey, collectionKeySize, fontFileEnumerator); + } +} + +/// +/// IDWriteFontFileEnumerator +[Guid("72755049-5ff7-435d-8348-4be97cfa6c7c")] +[NativeTypeName("struct IDWriteFontFileEnumerator : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFileEnumerator +{ + public static ref readonly Guid IID_IDWriteFontFileEnumerator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x49, 0x50, 0x75, 0x72, + 0xF7, 0x5F, + 0x5D, 0x43, + 0x83, + 0x48, + 0x4B, + 0xE9, + 0x7C, + 0xFA, + 0x6C, + 0x7C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFileEnumerator)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult MoveNext(Bool32* hasCurrentFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFileEnumerator*)Unsafe.AsPointer(ref this), hasCurrentFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentFontFile(IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFileEnumerator*)Unsafe.AsPointer(ref this), fontFile); + } +} + +/// +/// IDWriteLocalizedStrings +[Guid("08256209-099a-4b34-b86d-c22b110e7771")] +[NativeTypeName("struct IDWriteLocalizedStrings : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteLocalizedStrings +{ + public static ref readonly Guid IID_IDWriteLocalizedStrings + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x09, 0x62, 0x25, 0x08, + 0x9A, 0x09, + 0x34, 0x4B, + 0xB8, + 0x6D, + 0xC2, + 0x2B, + 0x11, + 0x0E, + 0x77, + 0x71 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteLocalizedStrings)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult FindLocaleName(ushort* localeName, uint* index, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this), localeName, index, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetLocaleNameLength(uint index, uint* length) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this), index, length); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLocaleName(uint index, ushort* localeName, uint size) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this), index, localeName, size); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetStringLength(uint index, uint* length) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this), index, length); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetString(uint index, ushort* stringBuffer, uint size) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteLocalizedStrings*)Unsafe.AsPointer(ref this), index, stringBuffer, size); + } +} + +/// +/// IDWriteFontCollection +[Guid("a84cee02-3eea-4eee-a827-87c1a02a0fcc")] +[NativeTypeName("struct IDWriteFontCollection : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontCollection +{ + public static ref readonly Guid IID_IDWriteFontCollection + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x02, 0xEE, 0x4C, 0xA8, + 0xEA, 0x3E, + 0xEE, 0x4E, + 0xA8, + 0x27, + 0x87, + 0xC1, + 0xA0, + 0x2A, + 0x0F, + 0xCC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontCollection)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetFontFamilyCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontCollection*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontFamily(uint index, IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontCollection*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult FindFamilyName(ushort* familyName, uint* index, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontCollection*)Unsafe.AsPointer(ref this), familyName, index, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontFromFontFace(IDWriteFontFace* fontFace, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontCollection*)Unsafe.AsPointer(ref this), fontFace, font); + } +} + +/// +/// IDWriteFontList +[Guid("1a0d8438-1d97-4ec1-aef9-a2fb86ed6acb")] +[NativeTypeName("struct IDWriteFontList : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontList +{ + public static ref readonly Guid IID_IDWriteFontList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x38, 0x84, 0x0D, 0x1A, + 0x97, 0x1D, + 0xC1, 0x4E, + 0xAE, + 0xF9, + 0xA2, + 0xFB, + 0x86, + 0xED, + 0x6A, + 0xCB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontList)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontList*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontList*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontList*)Unsafe.AsPointer(ref this), index, font); + } +} + +/// +/// IDWriteFontFamily +[Guid("da20d8ef-812a-4c43-9802-62ec4abd7add")] +[NativeTypeName("struct IDWriteFontFamily : IDWriteFontList")] +[NativeInheritance("IDWriteFontList")] +public unsafe partial struct IDWriteFontFamily +{ + public static ref readonly Guid IID_IDWriteFontFamily + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEF, 0xD8, 0x20, 0xDA, + 0x2A, 0x81, + 0x43, 0x4C, + 0x98, + 0x02, + 0x62, + 0xEC, + 0x4A, + 0xBD, + 0x7A, + 0xDD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFamily)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this), index, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFirstMatchingFont(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFont** matchingFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMatchingFonts(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFontList** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFamily*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFonts); + } +} + +/// +/// IDWriteFont +[Guid("acd16696-8c14-4f5d-877e-fe3fc1d32737")] +[NativeTypeName("struct IDWriteFont : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFont +{ + public static ref readonly Guid IID_IDWriteFont + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x96, 0x66, 0xD1, 0xAC, + 0x14, 0x8C, + 0x5D, 0x4F, + 0x87, + 0x7E, + 0xFE, + 0x3F, + 0xC1, + 0xD3, + 0x27, + 0x37 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFont)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontFamily(IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFont*)Unsafe.AsPointer(ref this), fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFont*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFont*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFont*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFont*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFont*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFont*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFont*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void GetMetrics(FontMetrics* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFont*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult HasCharacter(uint unicodeValue, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFont*)Unsafe.AsPointer(ref this), unicodeValue, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontFace(IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFont*)Unsafe.AsPointer(ref this), fontFace); + } +} + +/// +/// IDWriteTextFormat +[Guid("9c906818-31d7-4fd3-a151-7c5e225db55a")] +[NativeTypeName("struct IDWriteTextFormat : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteTextFormat +{ + public static ref readonly Guid IID_IDWriteTextFormat + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x18, 0x68, 0x90, 0x9C, + 0xD7, 0x31, + 0xD3, 0x4F, + 0xA1, + 0x51, + 0x7C, + 0x5E, + 0x22, + 0x5D, + 0xB5, + 0x5A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextFormat)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextFormat*)Unsafe.AsPointer(ref this), localeName, nameSize); + } +} + +/// +/// IDWriteTypography +[Guid("55f1112b-1dc2-4b3c-9541-f46894ed85b6")] +[NativeTypeName("struct IDWriteTypography : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteTypography +{ + public static ref readonly Guid IID_IDWriteTypography + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x2B, 0x11, 0xF1, 0x55, + 0xC2, 0x1D, + 0x3C, 0x4B, + 0x95, + 0x41, + 0xF4, + 0x68, + 0x94, + 0xED, + 0x85, + 0xB6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTypography)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddFontFeature(FontFeature* fontFeature) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTypography*)Unsafe.AsPointer(ref this), fontFeature); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFontFeatureCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTypography*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFontFeature(uint fontFeatureIndex, FontFeature* fontFeature) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTypography*)Unsafe.AsPointer(ref this), fontFeatureIndex, fontFeature); + } +} + +/// +/// IDWriteNumberSubstitution +[Guid("14885cc9-bab0-4f90-b6ed-5c366a2cd03d")] +[NativeTypeName("struct IDWriteNumberSubstitution : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteNumberSubstitution +{ + public static ref readonly Guid IID_IDWriteNumberSubstitution + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC9, 0x5C, 0x88, 0x14, + 0xB0, 0xBA, + 0x90, 0x4F, + 0xB6, + 0xED, + 0x5C, + 0x36, + 0x6A, + 0x2C, + 0xD0, + 0x3D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteNumberSubstitution)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + +} + +/// +/// IDWriteTextAnalysisSource +[Guid("688e1a58-5094-47c8-adc8-fbcea60ae92b")] +[NativeTypeName("struct IDWriteTextAnalysisSource : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteTextAnalysisSource +{ + public static ref readonly Guid IID_IDWriteTextAnalysisSource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x58, 0x1A, 0x8E, 0x68, + 0x94, 0x50, + 0xC8, 0x47, + 0xAD, + 0xC8, + 0xFB, + 0xCE, + 0xA6, + 0x0A, + 0xE9, + 0x2B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalysisSource)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetTextAtPosition(uint textPosition, ushort** textString, uint* textLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalysisSource*)Unsafe.AsPointer(ref this), textPosition, textString, textLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetTextBeforePosition(uint textPosition, ushort** textString, uint* textLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalysisSource*)Unsafe.AsPointer(ref this), textPosition, textString, textLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.ReadingDirection GetParagraphReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalysisSource*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLocaleName(uint textPosition, uint* textLength, ushort** localeName) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalysisSource*)Unsafe.AsPointer(ref this), textPosition, textLength, localeName); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetNumberSubstitution(uint textPosition, uint* textLength, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalysisSource*)Unsafe.AsPointer(ref this), textPosition, textLength, numberSubstitution); + } +} + +/// +/// IDWriteTextAnalysisSink +[Guid("5810cd44-0ca0-4701-b3fa-bec5182ae4f6")] +[NativeTypeName("struct IDWriteTextAnalysisSink : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteTextAnalysisSink +{ + public static ref readonly Guid IID_IDWriteTextAnalysisSink + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x44, 0xCD, 0x10, 0x58, + 0xA0, 0x0C, + 0x01, 0x47, + 0xB3, + 0xFA, + 0xBE, + 0xC5, + 0x18, + 0x2A, + 0xE4, + 0xF6 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalysisSink)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetScriptAnalysis(uint textPosition, uint textLength, ScriptAnalysis* scriptAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalysisSink*)Unsafe.AsPointer(ref this), textPosition, textLength, scriptAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetLineBreakpoints(uint textPosition, uint textLength, LineBreakpoint* lineBreakpoints) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalysisSink*)Unsafe.AsPointer(ref this), textPosition, textLength, lineBreakpoints); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetBidiLevel(uint textPosition, uint textLength, byte explicitLevel, byte resolvedLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalysisSink*)Unsafe.AsPointer(ref this), textPosition, textLength, explicitLevel, resolvedLevel); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetNumberSubstitution(uint textPosition, uint textLength, IDWriteNumberSubstitution* numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalysisSink*)Unsafe.AsPointer(ref this), textPosition, textLength, numberSubstitution); + } +} + +/// +/// IDWriteTextAnalyzer +[Guid("b7e6163e-7f46-43b4-84b3-e4e6249c365d")] +[NativeTypeName("struct IDWriteTextAnalyzer : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteTextAnalyzer +{ + public static ref readonly Guid IID_IDWriteTextAnalyzer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x3E, 0x16, 0xE6, 0xB7, + 0x46, 0x7F, + 0xB4, 0x43, + 0x84, + 0xB3, + 0xE4, + 0xE6, + 0x24, + 0x9C, + 0x36, + 0x5D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalyzer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AnalyzeScript(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AnalyzeBidi(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AnalyzeNumberSubstitution(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult AnalyzeLineBreakpoints(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetGlyphs(ushort* textString, uint textLength, IDWriteFontFace* fontFace, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, IDWriteNumberSubstitution* numberSubstitution, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, uint maxGlyphCount, ushort* clusterMap, ShapingTextProperties* textProps, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint* actualGlyphCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), textString, textLength, fontFace, isSideways, isRightToLeft, scriptAnalysis, localeName, numberSubstitution, features, featureRangeLengths, featureRanges, maxGlyphCount, clusterMap, textProps, glyphIndices, glyphProps, actualGlyphCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetGdiCompatibleGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextAnalyzer*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, pixelsPerDip, transform, useGdiNatural, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } +} + +/// +/// IDWriteInlineObject +[Guid("8339fde3-106f-47ab-8373-1c6295eb10b3")] +[NativeTypeName("struct IDWriteInlineObject : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteInlineObject +{ + public static ref readonly Guid IID_IDWriteInlineObject + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xE3, 0xFD, 0x39, 0x83, + 0x6F, 0x10, + 0xAB, 0x47, + 0x83, + 0x73, + 0x1C, + 0x62, + 0x95, + 0xEB, + 0x10, + 0xB3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteInlineObject)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY, Bool32 isSideways, Bool32 isRightToLeft, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteInlineObject*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY, isSideways, isRightToLeft, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMetrics(InlineObjectMetrics* metrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteInlineObject*)Unsafe.AsPointer(ref this), metrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteInlineObject*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetBreakConditions(BreakCondition* breakConditionBefore, BreakCondition* breakConditionAfter) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteInlineObject*)Unsafe.AsPointer(ref this), breakConditionBefore, breakConditionAfter); + } +} + +/// +/// IDWritePixelSnapping +[Guid("eaf3a2da-ecf4-4d24-b644-b34f6842024b")] +[NativeTypeName("struct IDWritePixelSnapping : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWritePixelSnapping +{ + public static ref readonly Guid IID_IDWritePixelSnapping + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0xA2, 0xF3, 0xEA, + 0xF4, 0xEC, + 0x24, 0x4D, + 0xB6, + 0x44, + 0xB3, + 0x4F, + 0x68, + 0x42, + 0x02, + 0x4B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWritePixelSnapping)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult IsPixelSnappingDisabled(void* clientDrawingContext, Bool32* isDisabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWritePixelSnapping*)Unsafe.AsPointer(ref this), clientDrawingContext, isDisabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentTransform(void* clientDrawingContext, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWritePixelSnapping*)Unsafe.AsPointer(ref this), clientDrawingContext, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPixelsPerDip(void* clientDrawingContext, float* pixelsPerDip) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWritePixelSnapping*)Unsafe.AsPointer(ref this), clientDrawingContext, pixelsPerDip); + } +} + +/// +/// IDWriteTextRenderer +[Guid("ef8a8135-5cc6-45fe-8825-c5a0724eb819")] +[NativeTypeName("struct IDWriteTextRenderer : IDWritePixelSnapping")] +[NativeInheritance("IDWritePixelSnapping")] +public unsafe partial struct IDWriteTextRenderer +{ + public static ref readonly Guid IID_IDWriteTextRenderer + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x35, 0x81, 0x8A, 0xEF, + 0xC6, 0x5C, + 0xFE, 0x45, + 0x88, + 0x25, + 0xC5, + 0xA0, + 0x72, + 0x4E, + 0xB8, + 0x19 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextRenderer)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult IsPixelSnappingDisabled(void* clientDrawingContext, Bool32* isDisabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, isDisabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentTransform(void* clientDrawingContext, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetPixelsPerDip(void* clientDrawingContext, float* pixelsPerDip) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, pixelsPerDip); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DrawGlyphRun(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, measuringMode, glyphRun, glyphRunDescription, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult DrawUnderline(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, Underline* underline, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, underline, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult DrawStrikethrough(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, Strikethrough* strikethrough, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, strikethrough, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult DrawInlineObject(void* clientDrawingContext, float originX, float originY, IDWriteInlineObject* inlineObject, Bool32 isSideways, Bool32 isRightToLeft, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextRenderer*)Unsafe.AsPointer(ref this), clientDrawingContext, originX, originY, inlineObject, isSideways, isRightToLeft, clientDrawingEffect); + } +} + +/// +/// IDWriteTextLayout +[Guid("53737037-6d14-410b-9bfe-0b182bb70961")] +[NativeTypeName("struct IDWriteTextLayout : IDWriteTextFormat")] +[NativeInheritance("IDWriteTextFormat")] +public unsafe partial struct IDWriteTextLayout +{ + public static ref readonly Guid IID_IDWriteTextLayout + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x37, 0x70, 0x73, 0x53, + 0x14, 0x6D, + 0x0B, 0x41, + 0x9B, + 0xFE, + 0x0B, + 0x18, + 0x2B, + 0xB7, + 0x09, + 0x61 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextLayout)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult SetMaxWidth(float maxWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), maxWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult SetMaxHeight(float maxHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), maxHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult SetFontCollection(IDWriteFontCollection* fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult SetFontFamilyName(ushort* fontFamilyName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontFamilyName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult SetFontWeight(FontWeight fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult SetFontStyle(FontStyle fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult SetFontStretch(FontStretch fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult SetFontSize(float fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetUnderline(Bool32 hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult SetStrikethrough(Bool32 hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult SetDrawingEffect(IUnknown* drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult SetInlineObject(IDWriteInlineObject* inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult SetTypography(IDWriteTypography* typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult SetLocaleName(ushort* localeName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), localeName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public float GetMaxWidth() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public float GetMaxHeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetFontCollection(uint currentPosition, IDWriteFontCollection** fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetFontFamilyNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetFontFamilyName(uint currentPosition, ushort* fontFamilyName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontFamilyName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult GetFontWeight(uint currentPosition, FontWeight* fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult GetFontStyle(uint currentPosition, FontStyle* fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult GetFontStretch(uint currentPosition, FontStretch* fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetFontSize(uint currentPosition, float* fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetUnderline(uint currentPosition, Bool32* hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult GetStrikethrough(uint currentPosition, Bool32* hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult GetDrawingEffect(uint currentPosition, IUnknown** drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetInlineObject(uint currentPosition, IDWriteInlineObject** inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetTypography(uint currentPosition, IDWriteTypography** typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetLocaleNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult GetLocaleName(uint currentPosition, ushort* localeName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), currentPosition, localeName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult GetLineMetrics(LineMetrics* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult GetMetrics(TextMetrics* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult GetClusterMetrics(ClusterMetrics* clusterMetrics, uint maxClusterCount, uint* actualClusterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), clusterMetrics, maxClusterCount, actualClusterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult DetermineMinWidth(float* minWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), minWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult HitTestPoint(float pointX, float pointY, Bool32* isTrailingHit, Bool32* isInside, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), pointX, pointY, isTrailingHit, isInside, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult HitTestTextPosition(uint textPosition, Bool32 isTrailingHit, float* pointX, float* pointY, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), textPosition, isTrailingHit, pointX, pointY, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult HitTestTextRange(uint textPosition, uint textLength, float originX, float originY, HitTestMetrics* hitTestMetrics, uint maxHitTestMetricsCount, uint* actualHitTestMetricsCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((IDWriteTextLayout*)Unsafe.AsPointer(ref this), textPosition, textLength, originX, originY, hitTestMetrics, maxHitTestMetricsCount, actualHitTestMetricsCount); + } +} + +/// +/// IDWriteBitmapRenderTarget +[Guid("5e5a32a3-8dff-4773-9ff6-0696eab77267")] +[NativeTypeName("struct IDWriteBitmapRenderTarget : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteBitmapRenderTarget +{ + public static ref readonly Guid IID_IDWriteBitmapRenderTarget + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA3, 0x32, 0x5A, 0x5E, + 0xFF, 0x8D, + 0x73, 0x47, + 0x9F, + 0xF6, + 0x06, + 0x96, + 0xEA, + 0xB7, + 0x72, + 0x67 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteBitmapRenderTarget)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DrawGlyphRun(float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun* glyphRun, IDWriteRenderingParams* renderingParams, uint textColor, RawRect* blackBoxRect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, measuringMode, glyphRun, renderingParams, textColor, blackBoxRect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public IntPtr GetMemoryDC() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetPixelsPerDip() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPixelsPerDip(float pixelsPerDip) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), pixelsPerDip); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetCurrentTransform(Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetCurrentTransform(Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSize(System.Drawing.Size** size) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), size); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Resize(uint width, uint height) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteBitmapRenderTarget*)Unsafe.AsPointer(ref this), width, height); + } +} + +/// +/// IDWriteGdiInterop +[Guid("1edd9491-9853-4299-898f-6432983b6f3a")] +[NativeTypeName("struct IDWriteGdiInterop : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteGdiInterop +{ + public static ref readonly Guid IID_IDWriteGdiInterop + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x91, 0x94, 0xDD, 0x1E, + 0x53, 0x98, + 0x99, 0x42, + 0x89, + 0x8F, + 0x64, + 0x32, + 0x98, + 0x3B, + 0x6F, + 0x3A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteGdiInterop)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontFromLOGFONT(Win32.Graphics.Gdi.LogFontW* logFont, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteGdiInterop*)Unsafe.AsPointer(ref this), logFont, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult ConvertFontToLOGFONT(IDWriteFont* font, Win32.Graphics.Gdi.LogFontW** logFont, Bool32* isSystemFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteGdiInterop*)Unsafe.AsPointer(ref this), font, logFont, isSystemFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ConvertFontFaceToLOGFONT(IDWriteFontFace* font, Win32.Graphics.Gdi.LogFontW** logFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteGdiInterop*)Unsafe.AsPointer(ref this), font, logFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontFaceFromHdc(IntPtr hdc, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteGdiInterop*)Unsafe.AsPointer(ref this), hdc, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateBitmapRenderTarget(IntPtr hdc, uint width, uint height, IDWriteBitmapRenderTarget** renderTarget) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteGdiInterop*)Unsafe.AsPointer(ref this), hdc, width, height, renderTarget); + } +} + +/// +/// IDWriteGlyphRunAnalysis +[Guid("7d97dbf7-e085-42d4-81e3-6a883bded118")] +[NativeTypeName("struct IDWriteGlyphRunAnalysis : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteGlyphRunAnalysis +{ + public static ref readonly Guid IID_IDWriteGlyphRunAnalysis + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF7, 0xDB, 0x97, 0x7D, + 0x85, 0xE0, + 0xD4, 0x42, + 0x81, + 0xE3, + 0x6A, + 0x88, + 0x3B, + 0xDE, + 0xD1, + 0x18 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteGlyphRunAnalysis)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetAlphaTextureBounds(TextureType textureType, RawRect* textureBounds) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteGlyphRunAnalysis*)Unsafe.AsPointer(ref this), textureType, textureBounds); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateAlphaTexture(TextureType textureType, RawRect* textureBounds, byte* alphaValues, uint bufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteGlyphRunAnalysis*)Unsafe.AsPointer(ref this), textureType, textureBounds, alphaValues, bufferSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetAlphaBlendParams(IDWriteRenderingParams* renderingParams, float* blendGamma, float* blendEnhancedContrast, float* blendClearTypeLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteGlyphRunAnalysis*)Unsafe.AsPointer(ref this), renderingParams, blendGamma, blendEnhancedContrast, blendClearTypeLevel); + } +} + +/// +/// IDWriteFactory +[Guid("b859ee5a-d838-4b5b-a2e8-1adc7d93db48")] +[NativeTypeName("struct IDWriteFactory : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFactory +{ + public static ref readonly Guid IID_IDWriteFactory + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5A, 0xEE, 0x59, 0xB8, + 0x38, 0xD8, + 0x5B, 0x4B, + 0xA2, + 0xE8, + 0x1A, + 0xDC, + 0x7D, + 0x93, + 0xDB, + 0x48 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } +} + +/// +/// IDWriteFactory1 +[Guid("30572f99-dac6-41db-a16e-0486307e606a")] +[NativeTypeName("struct IDWriteFactory1 : IDWriteFactory")] +[NativeInheritance("IDWriteFactory")] +public unsafe partial struct IDWriteFactory1 +{ + public static ref readonly Guid IID_IDWriteFactory1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x99, 0x2F, 0x57, 0x30, + 0xC6, 0xDA, + 0xDB, 0x41, + 0xA1, + 0x6E, + 0x04, + 0x86, + 0x30, + 0x7E, + 0x60, + 0x6A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory1*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } +} + +/// +/// IDWriteFontFace1 +[Guid("a71efdb4-9fdb-4838-ad90-cfc3be8c3daf")] +[NativeTypeName("struct IDWriteFontFace1 : IDWriteFontFace")] +[NativeInheritance("IDWriteFontFace")] +public unsafe partial struct IDWriteFontFace1 +{ + public static ref readonly Guid IID_IDWriteFontFace1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB4, 0xFD, 0x1E, 0xA7, + 0xDB, 0x9F, + 0x38, 0x48, + 0xAD, + 0x90, + 0xCF, + 0xC3, + 0xBE, + 0x8C, + 0x3D, + 0xAF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace1*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFont1 +[Guid("acd16696-8c14-4f5d-877e-fe3fc1d32738")] +[NativeTypeName("struct IDWriteFont1 : IDWriteFont")] +[NativeInheritance("IDWriteFont")] +public unsafe partial struct IDWriteFont1 +{ + public static ref readonly Guid IID_IDWriteFont1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x96, 0x66, 0xD1, 0xAC, + 0x14, 0x8C, + 0x5D, 0x4F, + 0x87, + 0x7E, + 0xFE, + 0x3F, + 0xC1, + 0xD3, + 0x27, + 0x38 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFont1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontFamily(IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFont1*)Unsafe.AsPointer(ref this), fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFont1*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFont1*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void GetMetrics(FontMetrics* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFont1*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult HasCharacter(uint unicodeValue, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFont1*)Unsafe.AsPointer(ref this), unicodeValue, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontFace(IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFont1*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFont1*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFont1*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFont1*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFont1*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteRenderingParams1 +[Guid("94413cf4-a6fc-4248-8b50-6674348fcad3")] +[NativeTypeName("struct IDWriteRenderingParams1 : IDWriteRenderingParams")] +[NativeInheritance("IDWriteRenderingParams")] +public unsafe partial struct IDWriteRenderingParams1 +{ + public static ref readonly Guid IID_IDWriteRenderingParams1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF4, 0x3C, 0x41, 0x94, + 0xFC, 0xA6, + 0x48, 0x42, + 0x8B, + 0x50, + 0x66, + 0x74, + 0x34, + 0x8F, + 0xCA, + 0xD3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRenderingParams1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public float GetGamma() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public float GetEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetClearTypeLevel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.PixelGeometry GetPixelGeometry() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.RenderingMode GetRenderingMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public float GetGrayscaleEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteRenderingParams1*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteTextAnalyzer1 +[Guid("80dad800-e21f-4e83-96ce-bfcce500db7c")] +[NativeTypeName("struct IDWriteTextAnalyzer1 : IDWriteTextAnalyzer")] +[NativeInheritance("IDWriteTextAnalyzer")] +public unsafe partial struct IDWriteTextAnalyzer1 +{ + public static ref readonly Guid IID_IDWriteTextAnalyzer1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x00, 0xD8, 0xDA, 0x80, + 0x1F, 0xE2, + 0x83, 0x4E, + 0x96, + 0xCE, + 0xBF, + 0xCC, + 0xE5, + 0x00, + 0xDB, + 0x7C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalyzer1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AnalyzeScript(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AnalyzeBidi(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AnalyzeNumberSubstitution(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult AnalyzeLineBreakpoints(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetGlyphs(ushort* textString, uint textLength, IDWriteFontFace* fontFace, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, IDWriteNumberSubstitution* numberSubstitution, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, uint maxGlyphCount, ushort* clusterMap, ShapingTextProperties* textProps, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint* actualGlyphCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), textString, textLength, fontFace, isSideways, isRightToLeft, scriptAnalysis, localeName, numberSubstitution, features, featureRangeLengths, featureRanges, maxGlyphCount, clusterMap, textProps, glyphIndices, glyphProps, actualGlyphCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetGdiCompatibleGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, pixelsPerDip, transform, useGdiNatural, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ApplyCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, uint textLength, uint glyphCount, ushort* clusterMap, float* glyphAdvances, GlyphOffset* glyphOffsets, ShapingGlyphProperties* glyphProperties, float* modifiedGlyphAdvances, GlyphOffset* modifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textLength, glyphCount, clusterMap, glyphAdvances, glyphOffsets, glyphProperties, modifiedGlyphAdvances, modifiedGlyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetBaseline(IDWriteFontFace* fontFace, Baseline baseline, Bool32 isVertical, Bool32 isSimulationAllowed, ScriptAnalysis* scriptAnalysis, ushort* localeName, int* baselineCoordinate, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), fontFace, baseline, isVertical, isSimulationAllowed, scriptAnalysis, localeName, baselineCoordinate, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult AnalyzeVerticalGlyphOrientation(IDWriteTextAnalysisSource1* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink1* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetGlyphOrientationTransform(GlyphOrientationAngle glyphOrientationAngle, Bool32 isSideways, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), glyphOrientationAngle, isSideways, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetScriptProperties(ScriptAnalysis* scriptAnalysis, ScriptProperties* scriptProperties) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), scriptAnalysis, scriptProperties); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetTextComplexity(ushort* textString, uint textLength, IDWriteFontFace* fontFace, Bool32* isTextSimple, uint* textLengthRead, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), textString, textLength, fontFace, isTextSimple, textLengthRead, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetJustificationOpportunities(IDWriteFontFace* fontFace, float fontEmSize, ScriptAnalysis* scriptAnalysis, uint textLength, uint glyphCount, ushort* textString, ushort* clusterMap, ShapingGlyphProperties* glyphProperties, JustificationOpportunity* justificationOpportunities) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), fontFace, fontEmSize, scriptAnalysis, textLength, glyphCount, textString, clusterMap, glyphProperties, justificationOpportunities); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult JustifyGlyphAdvances(float lineWidth, uint glyphCount, JustificationOpportunity* justificationOpportunities, float* glyphAdvances, GlyphOffset* glyphOffsets, float* justifiedGlyphAdvances, GlyphOffset* justifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), lineWidth, glyphCount, justificationOpportunities, glyphAdvances, glyphOffsets, justifiedGlyphAdvances, justifiedGlyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetJustifiedGlyphs(IDWriteFontFace* fontFace, float fontEmSize, ScriptAnalysis* scriptAnalysis, uint textLength, uint glyphCount, uint maxGlyphCount, ushort* clusterMap, ushort* glyphIndices, float* glyphAdvances, float* justifiedGlyphAdvances, GlyphOffset* justifiedGlyphOffsets, ShapingGlyphProperties* glyphProperties, uint* actualGlyphCount, ushort* modifiedClusterMap, ushort* modifiedGlyphIndices, float* modifiedGlyphAdvances, GlyphOffset* modifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextAnalyzer1*)Unsafe.AsPointer(ref this), fontFace, fontEmSize, scriptAnalysis, textLength, glyphCount, maxGlyphCount, clusterMap, glyphIndices, glyphAdvances, justifiedGlyphAdvances, justifiedGlyphOffsets, glyphProperties, actualGlyphCount, modifiedClusterMap, modifiedGlyphIndices, modifiedGlyphAdvances, modifiedGlyphOffsets); + } +} + +/// +/// IDWriteTextAnalysisSource1 +[Guid("639cfad8-0fb4-4b21-a58a-067920120009")] +[NativeTypeName("struct IDWriteTextAnalysisSource1 : IDWriteTextAnalysisSource")] +[NativeInheritance("IDWriteTextAnalysisSource")] +public unsafe partial struct IDWriteTextAnalysisSource1 +{ + public static ref readonly Guid IID_IDWriteTextAnalysisSource1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD8, 0xFA, 0x9C, 0x63, + 0xB4, 0x0F, + 0x21, 0x4B, + 0xA5, + 0x8A, + 0x06, + 0x79, + 0x20, + 0x12, + 0x00, + 0x09 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalysisSource1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetTextAtPosition(uint textPosition, ushort** textString, uint* textLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this), textPosition, textString, textLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetTextBeforePosition(uint textPosition, ushort** textString, uint* textLength) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this), textPosition, textString, textLength); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.ReadingDirection GetParagraphReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLocaleName(uint textPosition, uint* textLength, ushort** localeName) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this), textPosition, textLength, localeName); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetNumberSubstitution(uint textPosition, uint* textLength, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this), textPosition, textLength, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetVerticalGlyphOrientation(uint textPosition, uint* textLength, VerticalGlyphOrientation* glyphOrientation, byte* bidiLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextAnalysisSource1*)Unsafe.AsPointer(ref this), textPosition, textLength, glyphOrientation, bidiLevel); + } +} + +/// +/// IDWriteTextAnalysisSink1 +[Guid("b0d941a0-85e7-4d8b-9fd3-5ced9934482a")] +[NativeTypeName("struct IDWriteTextAnalysisSink1 : IDWriteTextAnalysisSink")] +[NativeInheritance("IDWriteTextAnalysisSink")] +public unsafe partial struct IDWriteTextAnalysisSink1 +{ + public static ref readonly Guid IID_IDWriteTextAnalysisSink1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA0, 0x41, 0xD9, 0xB0, + 0xE7, 0x85, + 0x8B, 0x4D, + 0x9F, + 0xD3, + 0x5C, + 0xED, + 0x99, + 0x34, + 0x48, + 0x2A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalysisSink1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetScriptAnalysis(uint textPosition, uint textLength, ScriptAnalysis* scriptAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalysisSink1*)Unsafe.AsPointer(ref this), textPosition, textLength, scriptAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetLineBreakpoints(uint textPosition, uint textLength, LineBreakpoint* lineBreakpoints) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalysisSink1*)Unsafe.AsPointer(ref this), textPosition, textLength, lineBreakpoints); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetBidiLevel(uint textPosition, uint textLength, byte explicitLevel, byte resolvedLevel) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalysisSink1*)Unsafe.AsPointer(ref this), textPosition, textLength, explicitLevel, resolvedLevel); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetNumberSubstitution(uint textPosition, uint textLength, IDWriteNumberSubstitution* numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalysisSink1*)Unsafe.AsPointer(ref this), textPosition, textLength, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetGlyphOrientation(uint textPosition, uint textLength, GlyphOrientationAngle glyphOrientationAngle, byte adjustedBidiLevel, Bool32 isSideways, Bool32 isRightToLeft) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalysisSink1*)Unsafe.AsPointer(ref this), textPosition, textLength, glyphOrientationAngle, adjustedBidiLevel, isSideways, isRightToLeft); + } +} + +/// +/// IDWriteTextLayout1 +[Guid("9064d822-80a7-465c-a986-df65f78b8feb")] +[NativeTypeName("struct IDWriteTextLayout1 : IDWriteTextLayout")] +[NativeInheritance("IDWriteTextLayout")] +public unsafe partial struct IDWriteTextLayout1 +{ + public static ref readonly Guid IID_IDWriteTextLayout1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x22, 0xD8, 0x64, 0x90, + 0xA7, 0x80, + 0x5C, 0x46, + 0xA9, + 0x86, + 0xDF, + 0x65, + 0xF7, + 0x8B, + 0x8F, + 0xEB + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextLayout1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetMaxWidth(float maxWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), maxWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetMaxHeight(float maxHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), maxHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetFontCollection(IDWriteFontCollection* fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetFontFamilyName(ushort* fontFamilyName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontFamilyName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetFontWeight(FontWeight fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetFontStyle(FontStyle fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetFontStretch(FontStretch fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetFontSize(float fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetUnderline(Bool32 hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetStrikethrough(Bool32 hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetDrawingEffect(IUnknown* drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetInlineObject(IDWriteInlineObject* inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetTypography(IDWriteTypography* typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetLocaleName(ushort* localeName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), localeName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public float GetMaxWidth() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public float GetMaxHeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontCollection(uint currentPosition, IDWriteFontCollection** fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetFontFamilyNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontFamilyName(uint currentPosition, ushort* fontFamilyName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontFamilyName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetFontWeight(uint currentPosition, FontWeight* fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetFontStyle(uint currentPosition, FontStyle* fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetFontStretch(uint currentPosition, FontStretch* fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetFontSize(uint currentPosition, float* fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetUnderline(uint currentPosition, Bool32* hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetStrikethrough(uint currentPosition, Bool32* hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetDrawingEffect(uint currentPosition, IUnknown** drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetInlineObject(uint currentPosition, IDWriteInlineObject** inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult GetTypography(uint currentPosition, IDWriteTypography** typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetLocaleNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetLocaleName(uint currentPosition, ushort* localeName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, localeName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetLineMetrics(LineMetrics* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetMetrics(TextMetrics* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetClusterMetrics(ClusterMetrics* clusterMetrics, uint maxClusterCount, uint* actualClusterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), clusterMetrics, maxClusterCount, actualClusterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult DetermineMinWidth(float* minWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), minWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult HitTestPoint(float pointX, float pointY, Bool32* isTrailingHit, Bool32* isInside, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), pointX, pointY, isTrailingHit, isInside, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult HitTestTextPosition(uint textPosition, Bool32 isTrailingHit, float* pointX, float* pointY, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), textPosition, isTrailingHit, pointX, pointY, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult HitTestTextRange(uint textPosition, uint textLength, float originX, float originY, HitTestMetrics* hitTestMetrics, uint maxHitTestMetricsCount, uint* actualHitTestMetricsCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), textPosition, textLength, originX, originY, hitTestMetrics, maxHitTestMetricsCount, actualHitTestMetricsCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public HResult SetPairKerning(Bool32 isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public HResult GetPairKerning(uint currentPosition, Bool32* isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult SetCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult GetCharacterSpacing(uint currentPosition, float* leadingSpacing, float* trailingSpacing, float* minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((IDWriteTextLayout1*)Unsafe.AsPointer(ref this), currentPosition, leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } +} + +/// +/// IDWriteBitmapRenderTarget1 +[Guid("791e8298-3ef3-4230-9880-c9bdecc42064")] +[NativeTypeName("struct IDWriteBitmapRenderTarget1 : IDWriteBitmapRenderTarget")] +[NativeInheritance("IDWriteBitmapRenderTarget")] +public unsafe partial struct IDWriteBitmapRenderTarget1 +{ + public static ref readonly Guid IID_IDWriteBitmapRenderTarget1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x98, 0x82, 0x1E, 0x79, + 0xF3, 0x3E, + 0x30, 0x42, + 0x98, + 0x80, + 0xC9, + 0xBD, + 0xEC, + 0xC4, + 0x20, + 0x64 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteBitmapRenderTarget1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DrawGlyphRun(float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun* glyphRun, IDWriteRenderingParams* renderingParams, uint textColor, RawRect* blackBoxRect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, measuringMode, glyphRun, renderingParams, textColor, blackBoxRect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public IntPtr GetMemoryDC() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetPixelsPerDip() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetPixelsPerDip(float pixelsPerDip) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), pixelsPerDip); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetCurrentTransform(Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetCurrentTransform(Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetSize(System.Drawing.Size** size) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), size); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult Resize(uint width, uint height) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), width, height); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.TextAntialiasMode GetTextAntialiasMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetTextAntialiasMode(TextAntialiasMode antialiasMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteBitmapRenderTarget1*)Unsafe.AsPointer(ref this), antialiasMode); + } +} + +/// +/// IDWriteTextRenderer1 +[Guid("d3e0e934-22a0-427e-aae4-7d9574b59db1")] +[NativeTypeName("struct IDWriteTextRenderer1 : IDWriteTextRenderer")] +[NativeInheritance("IDWriteTextRenderer")] +public unsafe partial struct IDWriteTextRenderer1 +{ + public static ref readonly Guid IID_IDWriteTextRenderer1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x34, 0xE9, 0xE0, 0xD3, + 0xA0, 0x22, + 0x7E, 0x42, + 0xAA, + 0xE4, + 0x7D, + 0x95, + 0x74, + 0xB5, + 0x9D, + 0xB1 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextRenderer1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult DrawGlyphRun(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, measuringMode, glyphRun, glyphRunDescription, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult DrawUnderline(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, Underline* underline, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, underline, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult DrawStrikethrough(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, Strikethrough* strikethrough, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, strikethrough, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult DrawInlineObject(void* clientDrawingContext, float originX, float originY, IDWriteInlineObject* inlineObject, Bool32 isSideways, Bool32 isRightToLeft, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, originX, originY, inlineObject, isSideways, isRightToLeft, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult IsPixelSnappingDisabled(void* clientDrawingContext, Bool32* isDisabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, isDisabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetCurrentTransform(void* clientDrawingContext, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPixelsPerDip(void* clientDrawingContext, float* pixelsPerDip) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, pixelsPerDip); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult DrawGlyphRun(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, GlyphOrientationAngle orientationAngle, MeasuringMode measuringMode, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, orientationAngle, measuringMode, glyphRun, glyphRunDescription, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult DrawUnderline(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, GlyphOrientationAngle orientationAngle, Underline* underline, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, orientationAngle, underline, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult DrawStrikethrough(void* clientDrawingContext, float baselineOriginX, float baselineOriginY, GlyphOrientationAngle orientationAngle, Strikethrough* strikethrough, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, baselineOriginX, baselineOriginY, orientationAngle, strikethrough, clientDrawingEffect); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult DrawInlineObject(void* clientDrawingContext, float originX, float originY, GlyphOrientationAngle orientationAngle, IDWriteInlineObject* inlineObject, Bool32 isSideways, Bool32 isRightToLeft, IUnknown* clientDrawingEffect) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextRenderer1*)Unsafe.AsPointer(ref this), clientDrawingContext, originX, originY, orientationAngle, inlineObject, isSideways, isRightToLeft, clientDrawingEffect); + } +} + +/// +/// IDWriteTextFormat1 +[Guid("5f174b49-0d8b-4cfb-8bca-f1cce9d06c67")] +[NativeTypeName("struct IDWriteTextFormat1 : IDWriteTextFormat")] +[NativeInheritance("IDWriteTextFormat")] +public unsafe partial struct IDWriteTextFormat1 +{ + public static ref readonly Guid IID_IDWriteTextFormat1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x49, 0x4B, 0x17, 0x5F, + 0x8B, 0x0D, + 0xFB, 0x4C, + 0x8B, + 0xCA, + 0xF1, + 0xCC, + 0xE9, + 0xD0, + 0x6C, + 0x67 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextFormat1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextFormat1*)Unsafe.AsPointer(ref this), fontFallback); + } +} + +/// +/// IDWriteTextLayout2 +[Guid("1093c18f-8d5e-43f0-b064-0917311b525e")] +[NativeTypeName("struct IDWriteTextLayout2 : IDWriteTextLayout1")] +[NativeInheritance("IDWriteTextLayout1")] +public unsafe partial struct IDWriteTextLayout2 +{ + public static ref readonly Guid IID_IDWriteTextLayout2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x8F, 0xC1, 0x93, 0x10, + 0x5E, 0x8D, + 0xF0, 0x43, + 0xB0, + 0x64, + 0x09, + 0x17, + 0x31, + 0x1B, + 0x52, + 0x5E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextLayout2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetPairKerning(Bool32 isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetPairKerning(uint currentPosition, Bool32* isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetCharacterSpacing(uint currentPosition, float* leadingSpacing, float* trailingSpacing, float* minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetMaxWidth(float maxWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), maxWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetMaxHeight(float maxHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), maxHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetFontCollection(IDWriteFontCollection* fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetFontFamilyName(ushort* fontFamilyName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontFamilyName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetFontWeight(FontWeight fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetFontStyle(FontStyle fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetFontStretch(FontStretch fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetFontSize(float fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetUnderline(Bool32 hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetStrikethrough(Bool32 hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult SetDrawingEffect(IUnknown* drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetInlineObject(IDWriteInlineObject* inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult SetTypography(IDWriteTypography* typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult SetLocaleName(ushort* localeName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), localeName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public float GetMaxWidth() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public float GetMaxHeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetFontCollection(uint currentPosition, IDWriteFontCollection** fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetFontFamilyNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetFontFamilyName(uint currentPosition, ushort* fontFamilyName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontFamilyName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetFontWeight(uint currentPosition, FontWeight* fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetFontStyle(uint currentPosition, FontStyle* fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetFontStretch(uint currentPosition, FontStretch* fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetFontSize(uint currentPosition, float* fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult GetUnderline(uint currentPosition, Bool32* hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetStrikethrough(uint currentPosition, Bool32* hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetDrawingEffect(uint currentPosition, IUnknown** drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetInlineObject(uint currentPosition, IDWriteInlineObject** inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetTypography(uint currentPosition, IDWriteTypography** typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetLocaleNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetLocaleName(uint currentPosition, ushort* localeName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), currentPosition, localeName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult GetLineMetrics(LineMetrics* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetMetrics(TextMetrics* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetClusterMetrics(ClusterMetrics* clusterMetrics, uint maxClusterCount, uint* actualClusterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), clusterMetrics, maxClusterCount, actualClusterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult DetermineMinWidth(float* minWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), minWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult HitTestPoint(float pointX, float pointY, Bool32* isTrailingHit, Bool32* isInside, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), pointX, pointY, isTrailingHit, isInside, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult HitTestTextPosition(uint textPosition, Bool32 isTrailingHit, float* pointX, float* pointY, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), textPosition, isTrailingHit, pointX, pointY, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult HitTestTextRange(uint textPosition, uint textLength, float originX, float originY, HitTestMetrics* hitTestMetrics, uint maxHitTestMetricsCount, uint* actualHitTestMetricsCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), textPosition, textLength, originX, originY, hitTestMetrics, maxHitTestMetricsCount, actualHitTestMetricsCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public HResult GetMetrics(TextMetrics1* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((IDWriteTextLayout2*)Unsafe.AsPointer(ref this), fontFallback); + } +} + +/// +/// IDWriteTextAnalyzer2 +[Guid("553a9ff3-5693-4df7-b52b-74806f7f2eb9")] +[NativeTypeName("struct IDWriteTextAnalyzer2 : IDWriteTextAnalyzer1")] +[NativeInheritance("IDWriteTextAnalyzer1")] +public unsafe partial struct IDWriteTextAnalyzer2 +{ + public static ref readonly Guid IID_IDWriteTextAnalyzer2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF3, 0x9F, 0x3A, 0x55, + 0x93, 0x56, + 0xF7, 0x4D, + 0xB5, + 0x2B, + 0x74, + 0x80, + 0x6F, + 0x7F, + 0x2E, + 0xB9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextAnalyzer2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult ApplyCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, uint textLength, uint glyphCount, ushort* clusterMap, float* glyphAdvances, GlyphOffset* glyphOffsets, ShapingGlyphProperties* glyphProperties, float* modifiedGlyphAdvances, GlyphOffset* modifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textLength, glyphCount, clusterMap, glyphAdvances, glyphOffsets, glyphProperties, modifiedGlyphAdvances, modifiedGlyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetBaseline(IDWriteFontFace* fontFace, Baseline baseline, Bool32 isVertical, Bool32 isSimulationAllowed, ScriptAnalysis* scriptAnalysis, ushort* localeName, int* baselineCoordinate, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), fontFace, baseline, isVertical, isSimulationAllowed, scriptAnalysis, localeName, baselineCoordinate, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AnalyzeVerticalGlyphOrientation(IDWriteTextAnalysisSource1* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink1* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetGlyphOrientationTransform(GlyphOrientationAngle glyphOrientationAngle, Bool32 isSideways, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), glyphOrientationAngle, isSideways, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetScriptProperties(ScriptAnalysis* scriptAnalysis, ScriptProperties* scriptProperties) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), scriptAnalysis, scriptProperties); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetTextComplexity(ushort* textString, uint textLength, IDWriteFontFace* fontFace, Bool32* isTextSimple, uint* textLengthRead, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), textString, textLength, fontFace, isTextSimple, textLengthRead, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetJustificationOpportunities(IDWriteFontFace* fontFace, float fontEmSize, ScriptAnalysis* scriptAnalysis, uint textLength, uint glyphCount, ushort* textString, ushort* clusterMap, ShapingGlyphProperties* glyphProperties, JustificationOpportunity* justificationOpportunities) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), fontFace, fontEmSize, scriptAnalysis, textLength, glyphCount, textString, clusterMap, glyphProperties, justificationOpportunities); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult JustifyGlyphAdvances(float lineWidth, uint glyphCount, JustificationOpportunity* justificationOpportunities, float* glyphAdvances, GlyphOffset* glyphOffsets, float* justifiedGlyphAdvances, GlyphOffset* justifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), lineWidth, glyphCount, justificationOpportunities, glyphAdvances, glyphOffsets, justifiedGlyphAdvances, justifiedGlyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetJustifiedGlyphs(IDWriteFontFace* fontFace, float fontEmSize, ScriptAnalysis* scriptAnalysis, uint textLength, uint glyphCount, uint maxGlyphCount, ushort* clusterMap, ushort* glyphIndices, float* glyphAdvances, float* justifiedGlyphAdvances, GlyphOffset* justifiedGlyphOffsets, ShapingGlyphProperties* glyphProperties, uint* actualGlyphCount, ushort* modifiedClusterMap, ushort* modifiedGlyphIndices, float* modifiedGlyphAdvances, GlyphOffset* modifiedGlyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), fontFace, fontEmSize, scriptAnalysis, textLength, glyphCount, maxGlyphCount, clusterMap, glyphIndices, glyphAdvances, justifiedGlyphAdvances, justifiedGlyphOffsets, glyphProperties, actualGlyphCount, modifiedClusterMap, modifiedGlyphIndices, modifiedGlyphAdvances, modifiedGlyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult AnalyzeScript(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult AnalyzeBidi(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult AnalyzeNumberSubstitution(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult AnalyzeLineBreakpoints(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteTextAnalysisSink* analysisSink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, analysisSink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetGlyphs(ushort* textString, uint textLength, IDWriteFontFace* fontFace, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, IDWriteNumberSubstitution* numberSubstitution, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, uint maxGlyphCount, ushort* clusterMap, ShapingTextProperties* textProps, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint* actualGlyphCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), textString, textLength, fontFace, isSideways, isRightToLeft, scriptAnalysis, localeName, numberSubstitution, features, featureRangeLengths, featureRanges, maxGlyphCount, clusterMap, textProps, glyphIndices, glyphProps, actualGlyphCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetGdiCompatibleGlyphPlacements(ushort* textString, ushort* clusterMap, ShapingTextProperties* textProps, uint textLength, ushort* glyphIndices, ShapingGlyphProperties* glyphProps, uint glyphCount, IDWriteFontFace* fontFace, float fontEmSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, Bool32 isRightToLeft, ScriptAnalysis* scriptAnalysis, ushort* localeName, TypographicFeatures** features, uint* featureRangeLengths, uint featureRanges, float* glyphAdvances, GlyphOffset* glyphOffsets) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), textString, clusterMap, textProps, textLength, glyphIndices, glyphProps, glyphCount, fontFace, fontEmSize, pixelsPerDip, transform, useGdiNatural, isSideways, isRightToLeft, scriptAnalysis, localeName, features, featureRangeLengths, featureRanges, glyphAdvances, glyphOffsets); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetGlyphOrientationTransform(GlyphOrientationAngle glyphOrientationAngle, Bool32 isSideways, float originX, float originY, Matrix* transform) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), glyphOrientationAngle, isSideways, originX, originY, transform); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetTypographicFeatures(IDWriteFontFace* fontFace, ScriptAnalysis* scriptAnalysis, ushort* localeName, uint maxTagCount, uint* actualTagCount, FontFeatureTag* tags) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), fontFace, scriptAnalysis, localeName, maxTagCount, actualTagCount, tags); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CheckTypographicFeature(IDWriteFontFace* fontFace, ScriptAnalysis* scriptAnalysis, ushort* localeName, FontFeatureTag featureTag, uint glyphCount, ushort* glyphIndices, byte* featureApplies) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextAnalyzer2*)Unsafe.AsPointer(ref this), fontFace, scriptAnalysis, localeName, featureTag, glyphCount, glyphIndices, featureApplies); + } +} + +/// +/// IDWriteFontFallback +[Guid("efa008f9-f7a1-48bf-b05c-f224713cc0ff")] +[NativeTypeName("struct IDWriteFontFallback : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFallback +{ + public static ref readonly Guid IID_IDWriteFontFallback + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF9, 0x08, 0xA0, 0xEF, + 0xA1, 0xF7, + 0xBF, 0x48, + 0xB0, + 0x5C, + 0xF2, + 0x24, + 0x71, + 0x3C, + 0xC0, + 0xFF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFallback)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult MapCharacters(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteFontCollection* baseFontCollection, ushort* baseFamilyName, FontWeight baseWeight, FontStyle baseStyle, FontStretch baseStretch, uint* mappedLength, IDWriteFont** mappedFont, float* scale) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFallback*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, baseFontCollection, baseFamilyName, baseWeight, baseStyle, baseStretch, mappedLength, mappedFont, scale); + } +} + +/// +/// IDWriteFontFallbackBuilder +[Guid("fd882d06-8aba-4fb8-b849-8be8b73e14de")] +[NativeTypeName("struct IDWriteFontFallbackBuilder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFallbackBuilder +{ + public static ref readonly Guid IID_IDWriteFontFallbackBuilder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x06, 0x2D, 0x88, 0xFD, + 0xBA, 0x8A, + 0xB8, 0x4F, + 0xB8, + 0x49, + 0x8B, + 0xE8, + 0xB7, + 0x3E, + 0x14, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFallbackBuilder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddMapping(UnicodeRange* ranges, uint rangesCount, ushort** targetFamilyNames, uint targetFamilyNamesCount, IDWriteFontCollection* fontCollection, ushort* localeName, ushort* baseFamilyName, float scale) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFallbackBuilder*)Unsafe.AsPointer(ref this), ranges, rangesCount, targetFamilyNames, targetFamilyNamesCount, fontCollection, localeName, baseFamilyName, scale); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AddMappings(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFallbackBuilder*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFallbackBuilder*)Unsafe.AsPointer(ref this), fontFallback); + } +} + +/// +/// IDWriteFont2 +[Guid("29748ed6-8c9c-4a6a-be0b-d912e8538944")] +[NativeTypeName("struct IDWriteFont2 : IDWriteFont1")] +[NativeInheritance("IDWriteFont1")] +public unsafe partial struct IDWriteFont2 +{ + public static ref readonly Guid IID_IDWriteFont2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD6, 0x8E, 0x74, 0x29, + 0x9C, 0x8C, + 0x6A, 0x4A, + 0xBE, + 0x0B, + 0xD9, + 0x12, + 0xE8, + 0x53, + 0x89, + 0x44 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFont2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFont2*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFont2*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFont2*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFontFamily(IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFont2*)Unsafe.AsPointer(ref this), fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFont2*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFont2*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public void GetMetrics(FontMetrics* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFont2*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult HasCharacter(uint unicodeValue, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFont2*)Unsafe.AsPointer(ref this), unicodeValue, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateFontFace(IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFont2*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFont2*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFontFace2 +[Guid("d8b768ff-64bc-4e66-982b-ec8e87f693f7")] +[NativeTypeName("struct IDWriteFontFace2 : IDWriteFontFace1")] +[NativeInheritance("IDWriteFontFace1")] +public unsafe partial struct IDWriteFontFace2 +{ + public static ref readonly Guid IID_IDWriteFontFace2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFF, 0x68, 0xB7, 0xD8, + 0xBC, 0x64, + 0x66, 0x4E, + 0x98, + 0x2B, + 0xEC, + 0x8E, + 0x87, + 0xF6, + 0x93, + 0xF7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public uint GetColorPaletteCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public uint GetPaletteEntryCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetPaletteEntries(uint colorPaletteIndex, uint firstEntryIndex, uint entryCount, ColorF* paletteEntries) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), colorPaletteIndex, firstEntryIndex, entryCount, paletteEntries); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFontFace2*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } +} + +/// +/// IDWriteColorGlyphRunEnumerator +[Guid("d31fbe17-f157-41a2-8d24-cb779e0560e8")] +[NativeTypeName("struct IDWriteColorGlyphRunEnumerator : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteColorGlyphRunEnumerator +{ + public static ref readonly Guid IID_IDWriteColorGlyphRunEnumerator + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x17, 0xBE, 0x1F, 0xD3, + 0x57, 0xF1, + 0xA2, 0x41, + 0x8D, + 0x24, + 0xCB, + 0x77, + 0x9E, + 0x05, + 0x60, + 0xE8 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteColorGlyphRunEnumerator)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult MoveNext(Bool32* hasRun) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteColorGlyphRunEnumerator*)Unsafe.AsPointer(ref this), hasRun); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentRun(ColorGlyphRun** colorGlyphRun) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteColorGlyphRunEnumerator*)Unsafe.AsPointer(ref this), colorGlyphRun); + } +} + +/// +/// IDWriteRenderingParams2 +[Guid("f9d711c3-9777-40ae-87e8-3e5af9bf0948")] +[NativeTypeName("struct IDWriteRenderingParams2 : IDWriteRenderingParams1")] +[NativeInheritance("IDWriteRenderingParams1")] +public unsafe partial struct IDWriteRenderingParams2 +{ + public static ref readonly Guid IID_IDWriteRenderingParams2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC3, 0x11, 0xD7, 0xF9, + 0x77, 0x97, + 0xAE, 0x40, + 0x87, + 0xE8, + 0x3E, + 0x5A, + 0xF9, + 0xBF, + 0x09, + 0x48 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRenderingParams2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public float GetGrayscaleEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public float GetGamma() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public float GetClearTypeLevel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.PixelGeometry GetPixelGeometry() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.DirectWrite.RenderingMode GetRenderingMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.GridFitMode GetGridFitMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteRenderingParams2*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFactory2 +[Guid("0439fc60-ca44-4994-8dee-3a9af7b732ec")] +[NativeTypeName("struct IDWriteFactory2 : IDWriteFactory1")] +[NativeInheritance("IDWriteFactory1")] +public unsafe partial struct IDWriteFactory2 +{ + public static ref readonly Guid IID_IDWriteFactory2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x60, 0xFC, 0x39, 0x04, + 0x44, 0xCA, + 0x94, 0x49, + 0x8D, + 0xEE, + 0x3A, + 0x9A, + 0xF7, + 0xB7, + 0x32, + 0xEC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory2*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } +} + +/// +/// IDWriteRenderingParams3 +[Guid("b7924baa-391b-412a-8c5c-e44cc2d867dc")] +[NativeTypeName("struct IDWriteRenderingParams3 : IDWriteRenderingParams2")] +[NativeInheritance("IDWriteRenderingParams2")] +public unsafe partial struct IDWriteRenderingParams3 +{ + public static ref readonly Guid IID_IDWriteRenderingParams3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xAA, 0x4B, 0x92, 0xB7, + 0x1B, 0x39, + 0x2A, 0x41, + 0x8C, + 0x5C, + 0xE4, + 0x4C, + 0xC2, + 0xD8, + 0x67, + 0xDC + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRenderingParams3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Graphics.DirectWrite.GridFitMode GetGridFitMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public float GetGrayscaleEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public float GetGamma() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public float GetEnhancedContrast() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public float GetClearTypeLevel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.DirectWrite.PixelGeometry GetPixelGeometry() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.RenderingMode GetRenderingMode() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.RenderingMode1 GetRenderingMode1() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteRenderingParams3*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFactory3 +[Guid("9a1b41c3-d3bb-466a-87fc-fe67556a3b65")] +[NativeTypeName("struct IDWriteFactory3 : IDWriteFactory2")] +[NativeInheritance("IDWriteFactory2")] +public unsafe partial struct IDWriteFactory3 +{ + public static ref readonly Guid IID_IDWriteFactory3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC3, 0x41, 0x1B, 0x9A, + 0xBB, 0xD3, + 0x6A, 0x46, + 0x87, + 0xFC, + 0xFE, + 0x67, + 0x55, + 0x6A, + 0x3B, + 0x65 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode1 renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode1 renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams3** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateFontFaceReference(ushort* filePath, ulong* lastWriteTime, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetSystemFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, IDWriteFontCollection1** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontSet, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, IDWriteFontCollection1** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetFontDownloadQueue(IDWriteFontDownloadQueue** fontDownloadQueue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFactory3*)Unsafe.AsPointer(ref this), fontDownloadQueue); + } +} + +/// +/// IDWriteFontSet +[Guid("53585141-d9f8-4095-8321-d73cf6bd116b")] +[NativeTypeName("struct IDWriteFontSet : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontSet +{ + public static ref readonly Guid IID_IDWriteFontSet + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x41, 0x51, 0x58, 0x53, + 0xF8, 0xD9, + 0x95, 0x40, + 0x83, + 0x21, + 0xD7, + 0x3C, + 0xF6, + 0xBD, + 0x11, + 0x6B + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSet)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSet*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult FindFontFaceReference(IDWriteFontFaceReference* fontFaceReference, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), fontFaceReference, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult FindFontFace(IDWriteFontFace* fontFace, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), fontFace, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPropertyValues(FontPropertyId propertyID, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), propertyID, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetPropertyValues(FontPropertyId propertyID, ushort* preferredLocaleNames, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), propertyID, preferredLocaleNames, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPropertyValues(uint listIndex, FontPropertyId propertyId, Bool32* exists, IDWriteLocalizedStrings** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), listIndex, propertyId, exists, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetPropertyOccurrenceCount(FontProperty* property, uint* propertyOccurrenceCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), property, propertyOccurrenceCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetMatchingFonts(ushort* familyName, FontWeight fontWeight, FontStretch fontStretch, FontStyle fontStyle, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), familyName, fontWeight, fontStretch, fontStyle, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetMatchingFonts(FontProperty* properties, uint propertyCount, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontSet*)Unsafe.AsPointer(ref this), properties, propertyCount, filteredSet); + } +} + +/// +/// IDWriteFontSetBuilder +[Guid("2f642afe-9c68-4f40-b8be-457401afcb3d")] +[NativeTypeName("struct IDWriteFontSetBuilder : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontSetBuilder +{ + public static ref readonly Guid IID_IDWriteFontSetBuilder + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFE, 0x2A, 0x64, 0x2F, + 0x68, 0x9C, + 0x40, 0x4F, + 0xB8, + 0xBE, + 0x45, + 0x74, + 0x01, + 0xAF, + 0xCB, + 0x3D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSetBuilder)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference, FontProperty* properties, uint propertyCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSetBuilder*)Unsafe.AsPointer(ref this), fontFaceReference, properties, propertyCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSetBuilder*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AddFontSet(IDWriteFontSet* fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSetBuilder*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSetBuilder*)Unsafe.AsPointer(ref this), fontSet); + } +} + +/// +/// IDWriteFontCollection1 +[Guid("53585141-d9f8-4095-8321-d73cf6bd116c")] +[NativeTypeName("struct IDWriteFontCollection1 : IDWriteFontCollection")] +[NativeInheritance("IDWriteFontCollection")] +public unsafe partial struct IDWriteFontCollection1 +{ + public static ref readonly Guid IID_IDWriteFontCollection1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x41, 0x51, 0x58, 0x53, + 0xF8, 0xD9, + 0x95, 0x40, + 0x83, + 0x21, + 0xD7, + 0x3C, + 0xF6, + 0xBD, + 0x11, + 0x6C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontCollection1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetFontFamilyCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontFamily(uint index, IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult FindFamilyName(ushort* familyName, uint* index, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this), familyName, index, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontFromFontFace(IDWriteFontFace* fontFace, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this), fontFace, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFamily(uint index, IDWriteFontFamily1** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontCollection1*)Unsafe.AsPointer(ref this), index, fontFamily); + } +} + +/// +/// IDWriteFontFamily1 +[Guid("da20d8ef-812a-4c43-9802-62ec4abd7adf")] +[NativeTypeName("struct IDWriteFontFamily1 : IDWriteFontFamily")] +[NativeInheritance("IDWriteFontFamily")] +public unsafe partial struct IDWriteFontFamily1 +{ + public static ref readonly Guid IID_IDWriteFontFamily1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEF, 0xD8, 0x20, 0xDA, + 0x2A, 0x81, + 0x43, 0x4C, + 0x98, + 0x02, + 0x62, + 0xEC, + 0x4A, + 0xBD, + 0x7A, + 0xDF + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFamily1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFirstMatchingFont(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFont** matchingFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetMatchingFonts(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFontList** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), index, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFont(uint listIndex, IDWriteFont3** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), listIndex, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFamily1*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } +} + +/// +/// IDWriteFontList1 +[Guid("da20d8ef-812a-4c43-9802-62ec4abd7ade")] +[NativeTypeName("struct IDWriteFontList1 : IDWriteFontList")] +[NativeInheritance("IDWriteFontList")] +public unsafe partial struct IDWriteFontList1 +{ + public static ref readonly Guid IID_IDWriteFontList1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xEF, 0xD8, 0x20, 0xDA, + 0x2A, 0x81, + 0x43, 0x4C, + 0x98, + 0x02, + 0x62, + 0xEC, + 0x4A, + 0xBD, + 0x7A, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontList1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontList1*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontList1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontList1*)Unsafe.AsPointer(ref this), index, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontList1*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFont(uint listIndex, IDWriteFont3** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontList1*)Unsafe.AsPointer(ref this), listIndex, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontList1*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } +} + +/// +/// IDWriteFontFaceReference +[Guid("5e7fa7ca-dde3-424c-89f0-9fcd6fed58cd")] +[NativeTypeName("struct IDWriteFontFaceReference : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontFaceReference +{ + public static ref readonly Guid IID_IDWriteFontFaceReference + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xCA, 0xA7, 0x7F, 0x5E, + 0xE3, 0xDD, + 0x4C, 0x42, + 0x89, + 0xF0, + 0x9F, + 0xCD, + 0x6F, + 0xED, + 0x58, + 0xCD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFaceReference)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontFace(IDWriteFontFace3** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateFontFaceWithSimulations(FontSimulations fontFaceSimulationFlags, IDWriteFontFace3** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Bool32 Equals(IDWriteFontFaceReference* fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetFontFaceIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFile(IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ulong GetLocalFileSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public ulong GetFileSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFileTime(ulong* lastWriteTime) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), lastWriteTime); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Graphics.DirectWrite.Locality GetLocality() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult EnqueueFontDownloadRequest() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult EnqueueCharacterDownloadRequest(ushort* characters, uint characterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), characters, characterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult EnqueueGlyphDownloadRequest(ushort* glyphIndices, uint glyphCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult EnqueueFileFragmentDownloadRequest(ulong fileOffset, ulong fragmentSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFaceReference*)Unsafe.AsPointer(ref this), fileOffset, fragmentSize); + } +} + +/// +/// IDWriteFont3 +[Guid("29748ed6-8c9c-4a6a-be0b-d912e8538944")] +[NativeTypeName("struct IDWriteFont3 : IDWriteFont2")] +[NativeInheritance("IDWriteFont2")] +public unsafe partial struct IDWriteFont3 +{ + public static ref readonly Guid IID_IDWriteFont3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD6, 0x8E, 0x74, 0x29, + 0x9C, 0x8C, + 0x6A, 0x4A, + 0xBE, + 0x0B, + 0xD9, + 0x12, + 0xE8, + 0x53, + 0x89, + 0x44 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFont3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFont3*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFont3*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFamily(IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFont3*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFont3*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public void GetMetrics(FontMetrics* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult HasCharacter(uint unicodeValue, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFont3*)Unsafe.AsPointer(ref this), unicodeValue, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateFontFace(IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateFontFace(IDWriteFontFace3** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public Bool32 Equals(IDWriteFont* font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFont3*)Unsafe.AsPointer(ref this), font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontFaceReference(IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFont3*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Bool32 HasCharacter(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFont3*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.Locality GetLocality() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFont3*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFontFace3 +[Guid("d37d7598-09be-4222-a236-2081341cc1f2")] +[NativeTypeName("struct IDWriteFontFace3 : IDWriteFontFace2")] +[NativeInheritance("IDWriteFontFace2")] +public unsafe partial struct IDWriteFontFace3 +{ + public static ref readonly Guid IID_IDWriteFontFace3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x98, 0x75, 0x7D, 0xD3, + 0xBE, 0x09, + 0x22, 0x42, + 0xA2, + 0x36, + 0x20, + 0x81, + 0x34, + 0x1C, + 0xC1, + 0xF2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetColorPaletteCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetPaletteEntryCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetPaletteEntries(uint colorPaletteIndex, uint firstEntryIndex, uint entryCount, ColorF* paletteEntries) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), colorPaletteIndex, firstEntryIndex, entryCount, paletteEntries); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetFontFaceReference(IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public Bool32 HasCharacter(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode1* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public Bool32 IsCharacterLocal(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public Bool32 IsGlyphLocal(ushort glyphId) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphId); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult AreCharactersLocal(ushort* characters, uint characterCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), characters, characterCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult AreGlyphsLocal(ushort* glyphIndices, uint glyphCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFontFace3*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, enqueueIfNotLocal, isLocal); + } +} + +/// +/// IDWriteStringList +[Guid("cfee3140-1157-47ca-8b85-31bfcf3f2d0e")] +[NativeTypeName("struct IDWriteStringList : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteStringList +{ + public static ref readonly Guid IID_IDWriteStringList + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x40, 0x31, 0xEE, 0xCF, + 0x57, 0x11, + 0xCA, 0x47, + 0x8B, + 0x85, + 0x31, + 0xBF, + 0xCF, + 0x3F, + 0x2D, + 0x0E + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteStringList)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteStringList*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetLocaleNameLength(uint listIndex, uint* length) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteStringList*)Unsafe.AsPointer(ref this), listIndex, length); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetLocaleName(uint listIndex, ushort* localeName, uint size) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteStringList*)Unsafe.AsPointer(ref this), listIndex, localeName, size); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetStringLength(uint listIndex, uint* length) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteStringList*)Unsafe.AsPointer(ref this), listIndex, length); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetString(uint listIndex, ushort* stringBuffer, uint stringBufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteStringList*)Unsafe.AsPointer(ref this), listIndex, stringBuffer, stringBufferSize); + } +} + +/// +/// IDWriteFontDownloadListener +[Guid("b06fe5b9-43ec-4393-881b-dbe4dc72fda7")] +[NativeTypeName("struct IDWriteFontDownloadListener : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontDownloadListener +{ + public static ref readonly Guid IID_IDWriteFontDownloadListener + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB9, 0xE5, 0x6F, 0xB0, + 0xEC, 0x43, + 0x93, 0x43, + 0x88, + 0x1B, + 0xDB, + 0xE4, + 0xDC, + 0x72, + 0xFD, + 0xA7 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontDownloadListener)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public void DownloadCompleted(IDWriteFontDownloadQueue* downloadQueue, IUnknown* context, HResult downloadResult) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontDownloadListener*)Unsafe.AsPointer(ref this), downloadQueue, context, downloadResult); + } +} + +/// +/// IDWriteFontDownloadQueue +[Guid("b71e6052-5aea-4fa3-832e-f60d431f7e91")] +[NativeTypeName("struct IDWriteFontDownloadQueue : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontDownloadQueue +{ + public static ref readonly Guid IID_IDWriteFontDownloadQueue + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x52, 0x60, 0x1E, 0xB7, + 0xEA, 0x5A, + 0xA3, 0x4F, + 0x83, + 0x2E, + 0xF6, + 0x0D, + 0x43, + 0x1F, + 0x7E, + 0x91 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontDownloadQueue)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddListener(IDWriteFontDownloadListener* listener, uint* token) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this), listener, token); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult RemoveListener(uint token) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this), token); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Bool32 IsEmpty() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult BeginDownload(IUnknown* context) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this), context); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CancelDownload() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public ulong GetGenerationCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontDownloadQueue*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteGdiInterop1 +[Guid("4556be70-3abd-4f70-90be-421780a6f515")] +[NativeTypeName("struct IDWriteGdiInterop1 : IDWriteGdiInterop")] +[NativeInheritance("IDWriteGdiInterop")] +public unsafe partial struct IDWriteGdiInterop1 +{ + public static ref readonly Guid IID_IDWriteGdiInterop1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x70, 0xBE, 0x56, 0x45, + 0xBD, 0x3A, + 0x70, 0x4F, + 0x90, + 0xBE, + 0x42, + 0x17, + 0x80, + 0xA6, + 0xF5, + 0x15 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteGdiInterop1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontFromLOGFONT(Win32.Graphics.Gdi.LogFontW* logFont, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), logFont, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult ConvertFontToLOGFONT(IDWriteFont* font, Win32.Graphics.Gdi.LogFontW** logFont, Bool32* isSystemFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), font, logFont, isSystemFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ConvertFontFaceToLOGFONT(IDWriteFontFace* font, Win32.Graphics.Gdi.LogFontW** logFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), font, logFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontFaceFromHdc(IntPtr hdc, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), hdc, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateBitmapRenderTarget(IntPtr hdc, uint width, uint height, IDWriteBitmapRenderTarget** renderTarget) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), hdc, width, height, renderTarget); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateFontFromLOGFONT(Win32.Graphics.Gdi.LogFontW* logFont, IDWriteFontCollection* fontCollection, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), logFont, fontCollection, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFontSignature(IDWriteFontFace* fontFace, Win32.Graphics.Gdi.FontSignature** fontSignature) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), fontFace, fontSignature); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFontSignature(IDWriteFont* font, Win32.Graphics.Gdi.FontSignature** fontSignature) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), font, fontSignature); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetMatchingFontsByLOGFONT(Win32.Graphics.Gdi.LogFontA* logFont, IDWriteFontSet* fontSet, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteGdiInterop1*)Unsafe.AsPointer(ref this), logFont, fontSet, filteredSet); + } +} + +/// +/// IDWriteTextFormat2 +[Guid("f67e0edd-9e3d-4ecc-8c32-4183253dfe70")] +[NativeTypeName("struct IDWriteTextFormat2 : IDWriteTextFormat1")] +[NativeInheritance("IDWriteTextFormat1")] +public unsafe partial struct IDWriteTextFormat2 +{ + public static ref readonly Guid IID_IDWriteTextFormat2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDD, 0x0E, 0x7E, 0xF6, + 0x3D, 0x9E, + 0xCC, 0x4E, + 0x8C, + 0x32, + 0x41, + 0x83, + 0x25, + 0x3D, + 0xFE, + 0x70 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextFormat2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult SetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextFormat2*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } +} + +/// +/// IDWriteTextLayout3 +[Guid("07ddcd52-020e-4de8-ac33-6c953d83f92d")] +[NativeTypeName("struct IDWriteTextLayout3 : IDWriteTextLayout2")] +[NativeInheritance("IDWriteTextLayout2")] +public unsafe partial struct IDWriteTextLayout3 +{ + public static ref readonly Guid IID_IDWriteTextLayout3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x52, 0xCD, 0xDD, 0x07, + 0x0E, 0x02, + 0xE8, 0x4D, + 0xAC, + 0x33, + 0x6C, + 0x95, + 0x3D, + 0x83, + 0xF9, + 0x2D + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextLayout3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMetrics(TextMetrics1* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetPairKerning(Bool32 isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetPairKerning(uint currentPosition, Bool32* isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetCharacterSpacing(uint currentPosition, float* leadingSpacing, float* trailingSpacing, float* minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetMaxWidth(float maxWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), maxWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult SetMaxHeight(float maxHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), maxHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetFontCollection(IDWriteFontCollection* fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult SetFontFamilyName(ushort* fontFamilyName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontFamilyName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult SetFontWeight(FontWeight fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult SetFontStyle(FontStyle fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult SetFontStretch(FontStretch fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetFontSize(float fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult SetUnderline(Bool32 hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult SetStrikethrough(Bool32 hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult SetDrawingEffect(IUnknown* drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult SetInlineObject(IDWriteInlineObject* inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult SetTypography(IDWriteTypography* typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult SetLocaleName(ushort* localeName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), localeName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public float GetMaxWidth() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public float GetMaxHeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetFontCollection(uint currentPosition, IDWriteFontCollection** fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetFontFamilyNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetFontFamilyName(uint currentPosition, ushort* fontFamilyName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontFamilyName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetFontWeight(uint currentPosition, FontWeight* fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetFontStyle(uint currentPosition, FontStyle* fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetFontStretch(uint currentPosition, FontStretch* fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult GetFontSize(uint currentPosition, float* fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetUnderline(uint currentPosition, Bool32* hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetStrikethrough(uint currentPosition, Bool32* hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetDrawingEffect(uint currentPosition, IUnknown** drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult GetInlineObject(uint currentPosition, IDWriteInlineObject** inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult GetTypography(uint currentPosition, IDWriteTypography** typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetLocaleNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetLocaleName(uint currentPosition, ushort* localeName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), currentPosition, localeName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult GetLineMetrics(LineMetrics* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult GetMetrics(TextMetrics* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetClusterMetrics(ClusterMetrics* clusterMetrics, uint maxClusterCount, uint* actualClusterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), clusterMetrics, maxClusterCount, actualClusterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult DetermineMinWidth(float* minWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), minWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult HitTestPoint(float pointX, float pointY, Bool32* isTrailingHit, Bool32* isInside, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), pointX, pointY, isTrailingHit, isInside, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult HitTestTextPosition(uint textPosition, Bool32 isTrailingHit, float* pointX, float* pointY, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), textPosition, isTrailingHit, pointX, pointY, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult HitTestTextRange(uint textPosition, uint textLength, float originX, float originY, HitTestMetrics* hitTestMetrics, uint maxHitTestMetricsCount, uint* actualHitTestMetricsCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), textPosition, textLength, originX, originY, hitTestMetrics, maxHitTestMetricsCount, actualHitTestMetricsCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public HResult InvalidateLayout() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public HResult SetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public HResult GetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public HResult GetLineMetrics(LineMetrics1* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((IDWriteTextLayout3*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } +} + +/// +/// IDWriteColorGlyphRunEnumerator1 +[Guid("7c5f86da-c7a1-4f05-b8e1-55a179fe5a35")] +[NativeTypeName("struct IDWriteColorGlyphRunEnumerator1 : IDWriteColorGlyphRunEnumerator")] +[NativeInheritance("IDWriteColorGlyphRunEnumerator")] +public unsafe partial struct IDWriteColorGlyphRunEnumerator1 +{ + public static ref readonly Guid IID_IDWriteColorGlyphRunEnumerator1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xDA, 0x86, 0x5F, 0x7C, + 0xA1, 0xC7, + 0x05, 0x4F, + 0xB8, + 0xE1, + 0x55, + 0xA1, + 0x79, + 0xFE, + 0x5A, + 0x35 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteColorGlyphRunEnumerator1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult MoveNext(Bool32* hasRun) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteColorGlyphRunEnumerator1*)Unsafe.AsPointer(ref this), hasRun); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetCurrentRun(ColorGlyphRun** colorGlyphRun) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteColorGlyphRunEnumerator1*)Unsafe.AsPointer(ref this), colorGlyphRun); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetCurrentRun(ColorGlyphRun1** colorGlyphRun) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteColorGlyphRunEnumerator1*)Unsafe.AsPointer(ref this), colorGlyphRun); + } +} + +/// +/// IDWriteFontFace4 +[Guid("27f2a904-4eb8-441d-9678-0563f53e3e2f")] +[NativeTypeName("struct IDWriteFontFace4 : IDWriteFontFace3")] +[NativeInheritance("IDWriteFontFace3")] +public unsafe partial struct IDWriteFontFace4 +{ + public static ref readonly Guid IID_IDWriteFontFace4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x04, 0xA9, 0xF2, 0x27, + 0xB8, 0x4E, + 0x1D, 0x44, + 0x96, + 0x78, + 0x05, + 0x63, + 0xF5, + 0x3E, + 0x3E, + 0x2F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace4)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontFaceReference(IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Bool32 HasCharacter(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode1* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Bool32 IsCharacterLocal(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Bool32 IsGlyphLocal(ushort glyphId) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphId); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult AreCharactersLocal(ushort* characters, uint characterCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), characters, characterCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult AreGlyphsLocal(ushort* glyphIndices, uint glyphCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public uint GetColorPaletteCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public uint GetPaletteEntryCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetPaletteEntries(uint colorPaletteIndex, uint firstEntryIndex, uint entryCount, ColorF* paletteEntries) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), colorPaletteIndex, firstEntryIndex, entryCount, paletteEntries); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult GetGlyphImageFormats(ushort glyphId, uint pixelsPerEmFirst, uint pixelsPerEmLast, GlyphImageFormats* glyphImageFormats) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEmFirst, pixelsPerEmLast, glyphImageFormats); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public Graphics.DirectWrite.GlyphImageFormats GetGlyphImageFormats() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetGlyphImageData(ushort glyphId, uint pixelsPerEm, GlyphImageFormats glyphImageFormat, GlyphImageData* glyphData, void** glyphDataContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEm, glyphImageFormat, glyphData, glyphDataContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public void ReleaseGlyphImageData(void* glyphDataContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteFontFace4*)Unsafe.AsPointer(ref this), glyphDataContext); + } +} + +/// +/// IDWriteFactory4 +[Guid("4b0b5bd3-0797-4549-8ac5-fe915cc53856")] +[NativeTypeName("struct IDWriteFactory4 : IDWriteFactory3")] +[NativeInheritance("IDWriteFactory3")] +public unsafe partial struct IDWriteFactory4 +{ + public static ref readonly Guid IID_IDWriteFactory4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xD3, 0x5B, 0x0B, 0x4B, + 0x97, 0x07, + 0x49, 0x45, + 0x8A, + 0xC5, + 0xFE, + 0x91, + 0x5C, + 0xC5, + 0x38, + 0x56 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory4)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode1 renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode1 renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams3** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontFaceReference(ushort* filePath, ulong* lastWriteTime, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetSystemFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, IDWriteFontCollection1** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontSet, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, IDWriteFontCollection1** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFontDownloadQueue(IDWriteFontDownloadQueue** fontDownloadQueue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontDownloadQueue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult TranslateColorGlyphRun(System.Drawing.PointF* baselineOrigin, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, GlyphImageFormats desiredGlyphImageFormats, MeasuringMode measuringMode, Matrix* worldAndDpiTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator1** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, desiredGlyphImageFormats, measuringMode, worldAndDpiTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, System.Drawing.PointF* baselineOrigin, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), glyphRun, baselineOrigin, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, MeasuringMode measuringMode, System.Drawing.PointF* baselineOrigin, Matrix* worldAndDpiTransform, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFactory4*)Unsafe.AsPointer(ref this), glyphRun, measuringMode, baselineOrigin, worldAndDpiTransform, glyphOrigins); + } +} + +/// +/// IDWriteFontSetBuilder1 +[Guid("3ff7715f-3cdc-4dc6-9b72-ec5621dccafd")] +[NativeTypeName("struct IDWriteFontSetBuilder1 : IDWriteFontSetBuilder")] +[NativeInheritance("IDWriteFontSetBuilder")] +public unsafe partial struct IDWriteFontSetBuilder1 +{ + public static ref readonly Guid IID_IDWriteFontSetBuilder1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x5F, 0x71, 0xF7, 0x3F, + 0xDC, 0x3C, + 0xC6, 0x4D, + 0x9B, + 0x72, + 0xEC, + 0x56, + 0x21, + 0xDC, + 0xCA, + 0xFD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSetBuilder1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference, FontProperty* properties, uint propertyCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSetBuilder1*)Unsafe.AsPointer(ref this), fontFaceReference, properties, propertyCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSetBuilder1*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AddFontSet(IDWriteFontSet* fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSetBuilder1*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSetBuilder1*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult AddFontFile(IDWriteFontFile* fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSetBuilder1*)Unsafe.AsPointer(ref this), fontFile); + } +} + +/// +/// IDWriteAsyncResult +[Guid("ce25f8fd-863b-4d13-9651-c1f88dc73fe2")] +[NativeTypeName("struct IDWriteAsyncResult : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteAsyncResult +{ + public static ref readonly Guid IID_IDWriteAsyncResult + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xFD, 0xF8, 0x25, 0xCE, + 0x3B, 0x86, + 0x13, 0x4D, + 0x96, + 0x51, + 0xC1, + 0xF8, + 0x8D, + 0xC7, + 0x3F, + 0xE2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteAsyncResult)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public IntPtr GetWaitHandle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteAsyncResult*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetResult() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteAsyncResult*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteRemoteFontFileStream +[Guid("4db3757a-2c72-4ed9-b2b6-1ababe1aff9c")] +[NativeTypeName("struct IDWriteRemoteFontFileStream : IDWriteFontFileStream")] +[NativeInheritance("IDWriteFontFileStream")] +public unsafe partial struct IDWriteRemoteFontFileStream +{ + public static ref readonly Guid IID_IDWriteRemoteFontFileStream + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x7A, 0x75, 0xB3, 0x4D, + 0x72, 0x2C, + 0xD9, 0x4E, + 0xB2, + 0xB6, + 0x1A, + 0xBA, + 0xBE, + 0x1A, + 0xFF, + 0x9C + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRemoteFontFileStream)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult ReadFileFragment(void** fragmentStart, ulong fileOffset, ulong fragmentSize, void** fragmentContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), fragmentStart, fileOffset, fragmentSize, fragmentContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public void ReleaseFileFragment(void* fragmentContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), fragmentContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFileSize(ulong* fileSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), fileSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLastWriteTime(ulong* lastWriteTime) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), lastWriteTime); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetLocalFileSize(ulong* localFileSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), localFileSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFileFragmentLocality(ulong fileOffset, ulong fragmentSize, Bool32* isLocal, ulong* partialSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), fileOffset, fragmentSize, isLocal, partialSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.Locality GetLocality() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult BeginDownload(Guid* downloadOperationID, FileFragment* fileFragments, uint fragmentCount, IDWriteAsyncResult** asyncResult) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteRemoteFontFileStream*)Unsafe.AsPointer(ref this), downloadOperationID, fileFragments, fragmentCount, asyncResult); + } +} + +/// +/// IDWriteRemoteFontFileLoader +[Guid("68648c83-6ede-46c0-ab46-20083a887fde")] +[NativeTypeName("struct IDWriteRemoteFontFileLoader : IDWriteFontFileLoader")] +[NativeInheritance("IDWriteFontFileLoader")] +public unsafe partial struct IDWriteRemoteFontFileLoader +{ + public static ref readonly Guid IID_IDWriteRemoteFontFileLoader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x83, 0x8C, 0x64, 0x68, + 0xDE, 0x6E, + 0xC0, 0x46, + 0xAB, + 0x46, + 0x20, + 0x08, + 0x3A, + 0x88, + 0x7F, + 0xDE + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteRemoteFontFileLoader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateStreamFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileStream** fontFileStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteRemoteFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateRemoteStreamFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteRemoteFontFileStream** fontFileStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteRemoteFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetLocalityFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, Locality* locality) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteRemoteFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, locality); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateFontFileReferenceFromUrl(IDWriteFactory* factory, ushort* baseUrl, ushort* fontFileUrl, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteRemoteFontFileLoader*)Unsafe.AsPointer(ref this), factory, baseUrl, fontFileUrl, fontFile); + } +} + +/// +/// IDWriteInMemoryFontFileLoader +[Guid("dc102f47-a12d-4b1c-822d-9e117e33043f")] +[NativeTypeName("struct IDWriteInMemoryFontFileLoader : IDWriteFontFileLoader")] +[NativeInheritance("IDWriteFontFileLoader")] +public unsafe partial struct IDWriteInMemoryFontFileLoader +{ + public static ref readonly Guid IID_IDWriteInMemoryFontFileLoader + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x47, 0x2F, 0x10, 0xDC, + 0x2D, 0xA1, + 0x1C, 0x4B, + 0x82, + 0x2D, + 0x9E, + 0x11, + 0x7E, + 0x33, + 0x04, + 0x3F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteInMemoryFontFileLoader)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateStreamFromKey(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileStream** fontFileStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteInMemoryFontFileLoader*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateInMemoryFontFileReference(IDWriteFactory* factory, void* fontData, uint fontDataSize, IUnknown* ownerObject, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteInMemoryFontFileLoader*)Unsafe.AsPointer(ref this), factory, fontData, fontDataSize, ownerObject, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetFileCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteInMemoryFontFileLoader*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFactory5 +[Guid("958db99a-be2a-4f09-af7d-65189803d1d3")] +[NativeTypeName("struct IDWriteFactory5 : IDWriteFactory4")] +[NativeInheritance("IDWriteFactory4")] +public unsafe partial struct IDWriteFactory5 +{ + public static ref readonly Guid IID_IDWriteFactory5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9A, 0xB9, 0x8D, 0x95, + 0x2A, 0xBE, + 0x09, 0x4F, + 0xAF, + 0x7D, + 0x65, + 0x18, + 0x98, + 0x03, + 0xD1, + 0xD3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory5)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult TranslateColorGlyphRun(System.Drawing.PointF* baselineOrigin, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, GlyphImageFormats desiredGlyphImageFormats, MeasuringMode measuringMode, Matrix* worldAndDpiTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator1** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, desiredGlyphImageFormats, measuringMode, worldAndDpiTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, System.Drawing.PointF* baselineOrigin, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), glyphRun, baselineOrigin, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, MeasuringMode measuringMode, System.Drawing.PointF* baselineOrigin, Matrix* worldAndDpiTransform, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), glyphRun, measuringMode, baselineOrigin, worldAndDpiTransform, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode1 renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode1 renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams3** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateFontFaceReference(ushort* filePath, ulong* lastWriteTime, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetSystemFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, IDWriteFontCollection1** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontSet, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, IDWriteFontCollection1** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetFontDownloadQueue(IDWriteFontDownloadQueue** fontDownloadQueue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontDownloadQueue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder1** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateInMemoryFontFileLoader(IDWriteInMemoryFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateHttpFontFileLoader(ushort* referrerUrl, ushort* extraHeaders, IDWriteRemoteFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), referrerUrl, extraHeaders, newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public Graphics.DirectWrite.ContainerType AnalyzeContainerType(void* fileData, uint fileDataSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), fileData, fileDataSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult UnpackFontFile(ContainerType containerType, void* fileData, uint fileDataSize, IDWriteFontFileStream** unpackedFontStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFactory5*)Unsafe.AsPointer(ref this), containerType, fileData, fileDataSize, unpackedFontStream); + } +} + +/// +/// IDWriteFactory6 +[Guid("f3744d80-21f7-42eb-b35d-995bc72fc223")] +[NativeTypeName("struct IDWriteFactory6 : IDWriteFactory5")] +[NativeInheritance("IDWriteFactory5")] +public unsafe partial struct IDWriteFactory6 +{ + public static ref readonly Guid IID_IDWriteFactory6 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x80, 0x4D, 0x74, 0xF3, + 0xF7, 0x21, + 0xEB, 0x42, + 0xB3, + 0x5D, + 0x99, + 0x5B, + 0xC7, + 0x2F, + 0xC2, + 0x23 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory6)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder1** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateInMemoryFontFileLoader(IDWriteInMemoryFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult CreateHttpFontFileLoader(ushort* referrerUrl, ushort* extraHeaders, IDWriteRemoteFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), referrerUrl, extraHeaders, newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.ContainerType AnalyzeContainerType(void* fileData, uint fileDataSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fileData, fileDataSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult UnpackFontFile(ContainerType containerType, void* fileData, uint fileDataSize, IDWriteFontFileStream** unpackedFontStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), containerType, fileData, fileDataSize, unpackedFontStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult TranslateColorGlyphRun(System.Drawing.PointF* baselineOrigin, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, GlyphImageFormats desiredGlyphImageFormats, MeasuringMode measuringMode, Matrix* worldAndDpiTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator1** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, desiredGlyphImageFormats, measuringMode, worldAndDpiTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, System.Drawing.PointF* baselineOrigin, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), glyphRun, baselineOrigin, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, MeasuringMode measuringMode, System.Drawing.PointF* baselineOrigin, Matrix* worldAndDpiTransform, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), glyphRun, measuringMode, baselineOrigin, worldAndDpiTransform, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode1 renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode1 renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams3** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateFontFaceReference(ushort* filePath, ulong* lastWriteTime, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetSystemFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, IDWriteFontCollection1** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSet, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, IDWriteFontCollection1** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontDownloadQueue(IDWriteFontDownloadQueue** fontDownloadQueue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontDownloadQueue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontAxisValues, fontAxisValueCount, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreateFontResource(IDWriteFontFile* fontFile, uint faceIndex, IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetSystemFontSet(Bool32 includeDownloadableFonts, IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, FontFamilyModel fontFamilyModel, IDWriteFontCollection2** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontFamilyModel, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, FontFamilyModel fontFamilyModel, IDWriteFontCollection2** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSet, fontFamilyModel, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder2** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontAxisValue* fontAxisValues, uint fontAxisValueCount, float fontSize, ushort* localeName, IDWriteTextFormat3** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteFactory6*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontAxisValues, fontAxisValueCount, fontSize, localeName, textFormat); + } +} + +/// +/// IDWriteFontFace5 +[Guid("98eff3a5-b667-479a-b145-e2fa5b9fdc29")] +[NativeTypeName("struct IDWriteFontFace5 : IDWriteFontFace4")] +[NativeInheritance("IDWriteFontFace4")] +public unsafe partial struct IDWriteFontFace5 +{ + public static ref readonly Guid IID_IDWriteFontFace5 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA5, 0xF3, 0xEF, 0x98, + 0x67, 0xB6, + 0x9A, 0x47, + 0xB1, + 0x45, + 0xE2, + 0xFA, + 0x5B, + 0x9F, + 0xDC, + 0x29 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace5)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetGlyphImageFormats(ushort glyphId, uint pixelsPerEmFirst, uint pixelsPerEmLast, GlyphImageFormats* glyphImageFormats) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEmFirst, pixelsPerEmLast, glyphImageFormats); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public Graphics.DirectWrite.GlyphImageFormats GetGlyphImageFormats() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetGlyphImageData(ushort glyphId, uint pixelsPerEm, GlyphImageFormats glyphImageFormat, GlyphImageData* glyphData, void** glyphDataContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEm, glyphImageFormat, glyphData, glyphDataContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public void ReleaseGlyphImageData(void* glyphDataContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphDataContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFontFaceReference(IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Bool32 HasCharacter(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode1* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public Bool32 IsCharacterLocal(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public Bool32 IsGlyphLocal(ushort glyphId) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphId); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult AreCharactersLocal(ushort* characters, uint characterCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), characters, characterCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult AreGlyphsLocal(ushort* glyphIndices, uint glyphCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public uint GetColorPaletteCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public uint GetPaletteEntryCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetPaletteEntries(uint colorPaletteIndex, uint firstEntryIndex, uint entryCount, ColorF* paletteEntries) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), colorPaletteIndex, firstEntryIndex, entryCount, paletteEntries); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public uint GetFontAxisValueCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public Bool32 HasVariations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetFontResource(IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public Bool32 Equals(IDWriteFontFace* fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteFontFace5*)Unsafe.AsPointer(ref this), fontFace); + } +} + +/// +/// IDWriteFontResource +[Guid("1f803a76-6871-48e8-987f-b975551c50f2")] +[NativeTypeName("struct IDWriteFontResource : IUnknown")] +[NativeInheritance("IUnknown")] +public unsafe partial struct IDWriteFontResource +{ + public static ref readonly Guid IID_IDWriteFontResource + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x76, 0x3A, 0x80, 0x1F, + 0x71, 0x68, + 0xE8, 0x48, + 0x98, + 0x7F, + 0xB9, + 0x75, + 0x55, + 0x1C, + 0x50, + 0xF2 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontResource)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontFile(IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public uint GetFontFaceIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontResource*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetFontAxisCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontResource*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetDefaultFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFontAxisRanges(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Graphics.DirectWrite.FontAxisAttributes GetFontAxisAttributes(uint axisIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), axisIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetAxisNames(uint axisIndex, IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), axisIndex, names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public uint GetAxisValueNameCount(uint axisIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), axisIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetAxisValueNames(uint axisIndex, uint axisValueIndex, FontAxisRange* fontAxisRange, IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), axisIndex, axisValueIndex, fontAxisRange, names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Bool32 HasVariations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontResource*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontFace(FontSimulations fontSimulations, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontFace5** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), fontSimulations, fontAxisValues, fontAxisValueCount, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateFontFaceReference(FontSimulations fontSimulations, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontResource*)Unsafe.AsPointer(ref this), fontSimulations, fontAxisValues, fontAxisValueCount, fontFaceReference); + } +} + +/// +/// IDWriteFontFaceReference1 +[Guid("c081fe77-2fd1-41ac-a5a3-34983c4ba61a")] +[NativeTypeName("struct IDWriteFontFaceReference1 : IDWriteFontFaceReference")] +[NativeInheritance("IDWriteFontFaceReference")] +public unsafe partial struct IDWriteFontFaceReference1 +{ + public static ref readonly Guid IID_IDWriteFontFaceReference1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x77, 0xFE, 0x81, 0xC0, + 0xD1, 0x2F, + 0xAC, 0x41, + 0xA5, + 0xA3, + 0x34, + 0x98, + 0x3C, + 0x4B, + 0xA6, + 0x1A + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFaceReference1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontFace(IDWriteFontFace3** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateFontFaceWithSimulations(FontSimulations fontFaceSimulationFlags, IDWriteFontFace3** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Bool32 Equals(IDWriteFontFaceReference* fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public uint GetFontFaceIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFile(IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public ulong GetLocalFileSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public ulong GetFileSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFileTime(ulong* lastWriteTime) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), lastWriteTime); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public Graphics.DirectWrite.Locality GetLocality() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult EnqueueFontDownloadRequest() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult EnqueueCharacterDownloadRequest(ushort* characters, uint characterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), characters, characterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult EnqueueGlyphDownloadRequest(ushort* glyphIndices, uint glyphCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult EnqueueFileFragmentDownloadRequest(ulong fileOffset, ulong fragmentSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fileOffset, fragmentSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult CreateFontFace(IDWriteFontFace5** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public uint GetFontAxisValueCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFaceReference1*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } +} + +/// +/// IDWriteFontSetBuilder2 +[Guid("ee5ba612-b131-463c-8f4f-3189b9401e45")] +[NativeTypeName("struct IDWriteFontSetBuilder2 : IDWriteFontSetBuilder1")] +[NativeInheritance("IDWriteFontSetBuilder1")] +public unsafe partial struct IDWriteFontSetBuilder2 +{ + public static ref readonly Guid IID_IDWriteFontSetBuilder2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x12, 0xA6, 0x5B, 0xEE, + 0x31, 0xB1, + 0x3C, 0x46, + 0x8F, + 0x4F, + 0x31, + 0x89, + 0xB9, + 0x40, + 0x1E, + 0x45 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSetBuilder2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult AddFontFile(IDWriteFontFile* fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference, FontProperty* properties, uint propertyCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontFaceReference, properties, propertyCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult AddFontFaceReference(IDWriteFontFaceReference* fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult AddFontSet(IDWriteFontSet* fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult AddFont(IDWriteFontFile* fontFile, uint fontFaceIndex, FontSimulations fontSimulations, FontAxisValue* fontAxisValues, uint fontAxisValueCount, FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, FontProperty* properties, uint propertyCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), fontFile, fontFaceIndex, fontSimulations, fontAxisValues, fontAxisValueCount, fontAxisRanges, fontAxisRangeCount, properties, propertyCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult AddFontFile(ushort* filePath) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontSetBuilder2*)Unsafe.AsPointer(ref this), filePath); + } +} + +/// +/// IDWriteFontSet1 +[Guid("7e9fda85-6c92-4053-bc47-7ae3530db4d3")] +[NativeTypeName("struct IDWriteFontSet1 : IDWriteFontSet")] +[NativeInheritance("IDWriteFontSet")] +public unsafe partial struct IDWriteFontSet1 +{ + public static ref readonly Guid IID_IDWriteFontSet1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x85, 0xDA, 0x9F, 0x7E, + 0x92, 0x6C, + 0x53, 0x40, + 0xBC, + 0x47, + 0x7A, + 0xE3, + 0x53, + 0x0D, + 0xB4, + 0xD3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSet1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult FindFontFaceReference(IDWriteFontFaceReference* fontFaceReference, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontFaceReference, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult FindFontFace(IDWriteFontFace* fontFace, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontFace, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetPropertyValues(FontPropertyId propertyID, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), propertyID, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetPropertyValues(FontPropertyId propertyID, ushort* preferredLocaleNames, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), propertyID, preferredLocaleNames, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetPropertyValues(uint listIndex, FontPropertyId propertyId, Bool32* exists, IDWriteLocalizedStrings** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, propertyId, exists, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetPropertyOccurrenceCount(FontProperty* property, uint* propertyOccurrenceCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), property, propertyOccurrenceCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetMatchingFonts(ushort* familyName, FontWeight fontWeight, FontStretch fontStretch, FontStyle fontStyle, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), familyName, fontWeight, fontStretch, fontStyle, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetMatchingFonts(FontProperty* properties, uint propertyCount, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), properties, propertyCount, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetMatchingFonts(FontProperty* fontProperty, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontSet1** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontProperty, fontAxisValues, fontAxisValueCount, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult GetFirstFontResources(IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetFilteredFonts(uint* indices, uint indexCount, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), indices, indexCount, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult GetFilteredFonts(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFilteredFonts(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetFilteredFontIndices(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetFilteredFontIndices(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetFontAxisRanges(uint listIndex, FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetFontAxisRanges(FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateFontResource(uint listIndex, IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateFontFace(uint listIndex, IDWriteFontFace5** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontSet1*)Unsafe.AsPointer(ref this), listIndex); + } +} + +/// +/// IDWriteFontList2 +[Guid("c0763a34-77af-445a-b735-08c37b0a5bf5")] +[NativeTypeName("struct IDWriteFontList2 : IDWriteFontList1")] +[NativeInheritance("IDWriteFontList1")] +public unsafe partial struct IDWriteFontList2 +{ + public static ref readonly Guid IID_IDWriteFontList2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x34, 0x3A, 0x76, 0xC0, + 0xAF, 0x77, + 0x5A, 0x44, + 0xB7, + 0x35, + 0x08, + 0xC3, + 0x7B, + 0x0A, + 0x5B, + 0xF5 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontList2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFont(uint listIndex, IDWriteFont3** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), listIndex, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontList2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), index, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFontSet(IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontList2*)Unsafe.AsPointer(ref this), fontSet); + } +} + +/// +/// IDWriteFontFamily2 +[Guid("3ed49e77-a398-4261-b9cf-c126c2131ef3")] +[NativeTypeName("struct IDWriteFontFamily2 : IDWriteFontFamily1")] +[NativeInheritance("IDWriteFontFamily1")] +public unsafe partial struct IDWriteFontFamily2 +{ + public static ref readonly Guid IID_IDWriteFontFamily2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x77, 0x9E, 0xD4, 0x3E, + 0x98, 0xA3, + 0x61, 0x42, + 0xB9, + 0xCF, + 0xC1, + 0x26, + 0xC2, + 0x13, + 0x1E, + 0xF3 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFamily2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFont(uint listIndex, IDWriteFont3** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), listIndex, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFirstMatchingFont(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFont** matchingFont) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFont); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetMatchingFonts(FontWeight weight, FontStretch stretch, FontStyle style, IDWriteFontList** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), weight, stretch, style, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFont(uint index, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), index, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetMatchingFonts(FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontList2** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetFontSet(IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFamily2*)Unsafe.AsPointer(ref this), fontSet); + } +} + +/// +/// IDWriteFontCollection2 +[Guid("514039c6-4617-4064-bf8b-92ea83e506e0")] +[NativeTypeName("struct IDWriteFontCollection2 : IDWriteFontCollection1")] +[NativeInheritance("IDWriteFontCollection1")] +public unsafe partial struct IDWriteFontCollection2 +{ + public static ref readonly Guid IID_IDWriteFontCollection2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xC6, 0x39, 0x40, 0x51, + 0x17, 0x46, + 0x64, 0x40, + 0xBF, + 0x8B, + 0x92, + 0xEA, + 0x83, + 0xE5, + 0x06, + 0xE0 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontCollection2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontFamily(uint index, IDWriteFontFamily1** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public uint GetFontFamilyCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontFamily(uint index, IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult FindFamilyName(ushort* familyName, uint* index, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), familyName, index, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFromFontFace(IDWriteFontFace* fontFace, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), fontFace, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFontFamily(uint index, IDWriteFontFamily2** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetMatchingFonts(ushort* familyName, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontList2** fontList) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), familyName, fontAxisValues, fontAxisValueCount, fontList); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Graphics.DirectWrite.FontFamilyModel GetFontFamilyModel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontSet(IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontCollection2*)Unsafe.AsPointer(ref this), fontSet); + } +} + +/// +/// IDWriteTextLayout4 +[Guid("05a9bf42-223f-4441-b5fb-8263685f55e9")] +[NativeTypeName("struct IDWriteTextLayout4 : IDWriteTextLayout3")] +[NativeInheritance("IDWriteTextLayout3")] +public unsafe partial struct IDWriteTextLayout4 +{ + public static ref readonly Guid IID_IDWriteTextLayout4 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x42, 0xBF, 0xA9, 0x05, + 0x3F, 0x22, + 0x41, 0x44, + 0xB5, + 0xFB, + 0x82, + 0x63, + 0x68, + 0x5F, + 0x55, + 0xE9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextLayout4)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult InvalidateLayout() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult SetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetLineMetrics(LineMetrics1* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetMetrics(TextMetrics1* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetPairKerning(Bool32 isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetPairKerning(uint currentPosition, Bool32* isPairKerningEnabled, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, isPairKerningEnabled, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetCharacterSpacing(float leadingSpacing, float trailingSpacing, float minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetCharacterSpacing(uint currentPosition, float* leadingSpacing, float* trailingSpacing, float* minimumAdvanceWidth, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, leadingSpacing, trailingSpacing, minimumAdvanceWidth, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult SetMaxWidth(float maxWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), maxWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult SetMaxHeight(float maxHeight) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), maxHeight); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult SetFontCollection(IDWriteFontCollection* fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult SetFontFamilyName(ushort* fontFamilyName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontFamilyName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult SetFontWeight(FontWeight fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult SetFontStyle(FontStyle fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult SetFontStretch(FontStretch fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult SetFontSize(float fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult SetUnderline(Bool32 hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult SetStrikethrough(Bool32 hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult SetDrawingEffect(IUnknown* drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult SetInlineObject(IDWriteInlineObject* inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult SetTypography(IDWriteTypography* typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult SetLocaleName(ushort* localeName, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), localeName, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public float GetMaxWidth() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public float GetMaxHeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetFontCollection(uint currentPosition, IDWriteFontCollection** fontCollection, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontCollection, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetFontFamilyNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult GetFontFamilyName(uint currentPosition, ushort* fontFamilyName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontFamilyName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult GetFontWeight(uint currentPosition, FontWeight* fontWeight, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontWeight, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetFontStyle(uint currentPosition, FontStyle* fontStyle, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontStyle, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetFontStretch(uint currentPosition, FontStretch* fontStretch, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontStretch, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult GetFontSize(uint currentPosition, float* fontSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult GetUnderline(uint currentPosition, Bool32* hasUnderline, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, hasUnderline, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetStrikethrough(uint currentPosition, Bool32* hasStrikethrough, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, hasStrikethrough, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult GetDrawingEffect(uint currentPosition, IUnknown** drawingEffect, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, drawingEffect, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult GetInlineObject(uint currentPosition, IDWriteInlineObject** inlineObject, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, inlineObject, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult GetTypography(uint currentPosition, IDWriteTypography** typography, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, typography, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult GetLocaleNameLength(uint currentPosition, uint* nameLength, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, nameLength, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult GetLocaleName(uint currentPosition, ushort* localeName, uint nameSize, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, localeName, nameSize, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult Draw(void* clientDrawingContext, IDWriteTextRenderer* renderer, float originX, float originY) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), clientDrawingContext, renderer, originX, originY); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetLineMetrics(LineMetrics* lineMetrics, uint maxLineCount, uint* actualLineCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineMetrics, maxLineCount, actualLineCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult GetMetrics(TextMetrics* textMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), textMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult GetOverhangMetrics(OverhangMetrics* overhangs) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), overhangs); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetClusterMetrics(ClusterMetrics* clusterMetrics, uint maxClusterCount, uint* actualClusterCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), clusterMetrics, maxClusterCount, actualClusterCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult DetermineMinWidth(float* minWidth) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), minWidth); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult HitTestPoint(float pointX, float pointY, Bool32* isTrailingHit, Bool32* isInside, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), pointX, pointY, isTrailingHit, isInside, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult HitTestTextPosition(uint textPosition, Bool32 isTrailingHit, float* pointX, float* pointY, HitTestMetrics* hitTestMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), textPosition, isTrailingHit, pointX, pointY, hitTestMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult HitTestTextRange(uint textPosition, uint textLength, float originX, float originY, HitTestMetrics* hitTestMetrics, uint maxHitTestMetricsCount, uint* actualHitTestMetricsCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), textPosition, textLength, originX, originY, hitTestMetrics, maxHitTestMetricsCount, actualHitTestMetricsCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(60)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[60]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(61)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[61]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(62)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[62]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(63)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[63]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(64)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[64]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(65)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[65]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(66)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[66]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(67)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[67]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(68)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[68]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(69)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[69]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(70)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[70]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(71)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[71]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(72)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[72]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(73)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[73]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(74)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[74]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(75)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[75]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(76)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[76]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(77)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[77]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(78)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[78]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(79)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[79]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(80)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[80]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(81)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[81]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(82)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[82]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(83)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[83]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(84)] + public HResult SetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[84]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(85)] + public uint GetFontAxisValueCount(uint currentPosition) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[85]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(86)] + public HResult GetFontAxisValues(uint currentPosition, FontAxisValue* fontAxisValues, uint fontAxisValueCount, TextRange* textRange) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[86]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), currentPosition, fontAxisValues, fontAxisValueCount, textRange); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(87)] + public Graphics.DirectWrite.AutomaticFontAxes GetAutomaticFontAxes() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[87]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(88)] + public HResult SetAutomaticFontAxes(AutomaticFontAxes automaticFontAxes) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[88]))((IDWriteTextLayout4*)Unsafe.AsPointer(ref this), automaticFontAxes); + } +} + +/// +/// IDWriteTextFormat3 +[Guid("6d3b5641-e550-430d-a85b-b7bf48a93427")] +[NativeTypeName("struct IDWriteTextFormat3 : IDWriteTextFormat2")] +[NativeInheritance("IDWriteTextFormat2")] +public unsafe partial struct IDWriteTextFormat3 +{ + public static ref readonly Guid IID_IDWriteTextFormat3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x41, 0x56, 0x3B, 0x6D, + 0x50, 0xE5, + 0x0D, 0x43, + 0xA8, + 0x5B, + 0xB7, + 0xBF, + 0x48, + 0xA9, + 0x34, + 0x27 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteTextFormat3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult SetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetLineSpacing(LineSpacing* lineSpacingOptions) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), lineSpacingOptions); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult SetVerticalGlyphOrientation(VerticalGlyphOrientation glyphOrientation) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), glyphOrientation); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public Graphics.DirectWrite.VerticalGlyphOrientation GetVerticalGlyphOrientation() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult SetLastLineWrapping(Bool32 isLastLineWrappingEnabled) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), isLastLineWrappingEnabled); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public Bool32 GetLastLineWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult SetOpticalAlignment(OpticalAlignment opticalAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), opticalAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public Graphics.DirectWrite.OpticalAlignment GetOpticalAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult SetFontFallback(IDWriteFontFallback* fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult SetTextAlignment(TextAlignment textAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), textAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult SetParagraphAlignment(ParagraphAlignment paragraphAlignment) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), paragraphAlignment); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult SetWordWrapping(WordWrapping wordWrapping) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), wordWrapping); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult SetReadingDirection(ReadingDirection readingDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), readingDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult SetFlowDirection(FlowDirection flowDirection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), flowDirection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult SetIncrementalTabStop(float incrementalTabStop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), incrementalTabStop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult SetTrimming(Trimming* trimmingOptions, IDWriteInlineObject* trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult SetLineSpacing(LineSpacingMethod lineSpacingMethod, float lineSpacing, float baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public Graphics.DirectWrite.TextAlignment GetTextAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Graphics.DirectWrite.ParagraphAlignment GetParagraphAlignment() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Graphics.DirectWrite.WordWrapping GetWordWrapping() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public Graphics.DirectWrite.ReadingDirection GetReadingDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public Graphics.DirectWrite.FlowDirection GetFlowDirection() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public float GetIncrementalTabStop() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetTrimming(Trimming* trimmingOptions, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), trimmingOptions, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult GetLineSpacing(LineSpacingMethod* lineSpacingMethod, float* lineSpacing, float* baseline) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), lineSpacingMethod, lineSpacing, baseline); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetFontCollection(IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public uint GetFontFamilyNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult GetFontFamilyName(ushort* fontFamilyName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontFamilyName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public Graphics.DirectWrite.FontWeight GetFontWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public Graphics.DirectWrite.FontStyle GetFontStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public Graphics.DirectWrite.FontStretch GetFontStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public float GetFontSize() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public uint GetLocaleNameLength() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetLocaleName(ushort* localeName, uint nameSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), localeName, nameSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult SetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public uint GetFontAxisValueCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public Graphics.DirectWrite.AutomaticFontAxes GetAutomaticFontAxes() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult SetAutomaticFontAxes(AutomaticFontAxes automaticFontAxes) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteTextFormat3*)Unsafe.AsPointer(ref this), automaticFontAxes); + } +} + +/// +/// IDWriteFontFallback1 +[Guid("2397599d-dd0d-4681-bd6a-f4f31eaade77")] +[NativeTypeName("struct IDWriteFontFallback1 : IDWriteFontFallback")] +[NativeInheritance("IDWriteFontFallback")] +public unsafe partial struct IDWriteFontFallback1 +{ + public static ref readonly Guid IID_IDWriteFontFallback1 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x9D, 0x59, 0x97, 0x23, + 0x0D, 0xDD, + 0x81, 0x46, + 0xBD, + 0x6A, + 0xF4, + 0xF3, + 0x1E, + 0xAA, + 0xDE, + 0x77 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFallback1)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult MapCharacters(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteFontCollection* baseFontCollection, ushort* baseFamilyName, FontWeight baseWeight, FontStyle baseStyle, FontStretch baseStretch, uint* mappedLength, IDWriteFont** mappedFont, float* scale) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFallback1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, baseFontCollection, baseFamilyName, baseWeight, baseStyle, baseStretch, mappedLength, mappedFont, scale); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult MapCharacters(IDWriteTextAnalysisSource* analysisSource, uint textPosition, uint textLength, IDWriteFontCollection* baseFontCollection, ushort* baseFamilyName, FontAxisValue* fontAxisValues, uint fontAxisValueCount, uint* mappedLength, float* scale, IDWriteFontFace5** mappedFontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFallback1*)Unsafe.AsPointer(ref this), analysisSource, textPosition, textLength, baseFontCollection, baseFamilyName, fontAxisValues, fontAxisValueCount, mappedLength, scale, mappedFontFace); + } +} + +/// +/// IDWriteFontSet2 +[Guid("dc7ead19-e54c-43af-b2da-4e2b79ba3f7f")] +[NativeTypeName("struct IDWriteFontSet2 : IDWriteFontSet1")] +[NativeInheritance("IDWriteFontSet1")] +public unsafe partial struct IDWriteFontSet2 +{ + public static ref readonly Guid IID_IDWriteFontSet2 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x19, 0xAD, 0x7E, 0xDC, + 0x4C, 0xE5, + 0xAF, 0x43, + 0xB2, + 0xDA, + 0x4E, + 0x2B, + 0x79, + 0xBA, + 0x3F, + 0x7F + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSet2)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetMatchingFonts(FontProperty* fontProperty, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontSet1** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontProperty, fontAxisValues, fontAxisValueCount, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFirstFontResources(IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFilteredFonts(uint* indices, uint indexCount, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), indices, indexCount, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFilteredFonts(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFilteredFonts(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFilteredFontIndices(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFilteredFontIndices(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFontAxisRanges(uint listIndex, FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFontAxisRanges(FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult CreateFontResource(uint listIndex, IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateFontFace(uint listIndex, IDWriteFontFace5** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult FindFontFaceReference(IDWriteFontFaceReference* fontFaceReference, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontFaceReference, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult FindFontFace(IDWriteFontFace* fontFace, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), fontFace, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult GetPropertyValues(FontPropertyId propertyID, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), propertyID, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetPropertyValues(FontPropertyId propertyID, ushort* preferredLocaleNames, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), propertyID, preferredLocaleNames, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetPropertyValues(uint listIndex, FontPropertyId propertyId, Bool32* exists, IDWriteLocalizedStrings** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), listIndex, propertyId, exists, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetPropertyOccurrenceCount(FontProperty* property, uint* propertyOccurrenceCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), property, propertyOccurrenceCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetMatchingFonts(ushort* familyName, FontWeight fontWeight, FontStretch fontStretch, FontStyle fontStyle, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), familyName, fontWeight, fontStretch, fontStyle, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetMatchingFonts(FontProperty* properties, uint propertyCount, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this), properties, propertyCount, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public IntPtr GetExpirationEvent() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontSet2*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFontCollection3 +[Guid("a4d055a6-f9e3-4e25-93b7-9e309f3af8e9")] +[NativeTypeName("struct IDWriteFontCollection3 : IDWriteFontCollection2")] +[NativeInheritance("IDWriteFontCollection2")] +public unsafe partial struct IDWriteFontCollection3 +{ + public static ref readonly Guid IID_IDWriteFontCollection3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xA6, 0x55, 0xD0, 0xA4, + 0xE3, 0xF9, + 0x25, 0x4E, + 0x93, + 0xB7, + 0x9E, + 0x30, + 0x9F, + 0x3A, + 0xF8, + 0xE9 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontCollection3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult GetFontFamily(uint index, IDWriteFontFamily2** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMatchingFonts(ushort* familyName, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontList2** fontList) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), familyName, fontAxisValues, fontAxisValueCount, fontList); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Graphics.DirectWrite.FontFamilyModel GetFontFamilyModel() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontSet(IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFontFamily(uint index, IDWriteFontFamily1** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public uint GetFontFamilyCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFontFamily(uint index, IDWriteFontFamily** fontFamily) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), index, fontFamily); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult FindFamilyName(ushort* familyName, uint* index, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), familyName, index, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontFromFontFace(IDWriteFontFace* fontFace, IDWriteFont** font) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this), fontFace, font); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public IntPtr GetExpirationEvent() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontCollection3*)Unsafe.AsPointer(ref this)); + } +} + +/// +/// IDWriteFactory7 +[Guid("35d0e0b3-9076-4d2e-a016-a91b568a06b4")] +[NativeTypeName("struct IDWriteFactory7 : IDWriteFactory6")] +[NativeInheritance("IDWriteFactory6")] +public unsafe partial struct IDWriteFactory7 +{ + public static ref readonly Guid IID_IDWriteFactory7 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xB3, 0xE0, 0xD0, 0x35, + 0x76, 0x90, + 0x2E, 0x4D, + 0xA0, + 0x16, + 0xA9, + 0x1B, + 0x56, + 0x8A, + 0x06, + 0xB4 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFactory7)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontAxisValues, fontAxisValueCount, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult CreateFontResource(IDWriteFontFile* fontFile, uint faceIndex, IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetSystemFontSet(Bool32 includeDownloadableFonts, IDWriteFontSet1** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, FontFamilyModel fontFamilyModel, IDWriteFontCollection2** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontFamilyModel, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, FontFamilyModel fontFamilyModel, IDWriteFontCollection2** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSet, fontFamilyModel, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder2** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontAxisValue* fontAxisValues, uint fontAxisValueCount, float fontSize, ushort* localeName, IDWriteTextFormat3** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontAxisValues, fontAxisValueCount, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder1** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult CreateInMemoryFontFileLoader(IDWriteInMemoryFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult CreateHttpFontFileLoader(ushort* referrerUrl, ushort* extraHeaders, IDWriteRemoteFontFileLoader** newLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), referrerUrl, extraHeaders, newLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public Graphics.DirectWrite.ContainerType AnalyzeContainerType(void* fileData, uint fileDataSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fileData, fileDataSize); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult UnpackFontFile(ContainerType containerType, void* fileData, uint fileDataSize, IDWriteFontFileStream** unpackedFontStream) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), containerType, fileData, fileDataSize, unpackedFontStream); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult TranslateColorGlyphRun(System.Drawing.PointF* baselineOrigin, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, GlyphImageFormats desiredGlyphImageFormats, MeasuringMode measuringMode, Matrix* worldAndDpiTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator1** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), baselineOrigin, glyphRun, glyphRunDescription, desiredGlyphImageFormats, measuringMode, worldAndDpiTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, System.Drawing.PointF* baselineOrigin, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), glyphRun, baselineOrigin, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult ComputeGlyphOrigins(GlyphRun* glyphRun, MeasuringMode measuringMode, System.Drawing.PointF* baselineOrigin, Matrix* worldAndDpiTransform, System.Drawing.PointF** glyphOrigins) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), glyphRun, measuringMode, baselineOrigin, worldAndDpiTransform, glyphOrigins); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode1 renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode1 renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams3** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult CreateFontFaceReference(IDWriteFontFile* fontFile, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFile, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult CreateFontFaceReference(ushort* filePath, ulong* lastWriteTime, uint faceIndex, FontSimulations fontSimulations, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, faceIndex, fontSimulations, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetSystemFontSet(IDWriteFontSet** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult CreateFontSetBuilder(IDWriteFontSetBuilder** fontSetBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSetBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult CreateFontCollectionFromFontSet(IDWriteFontSet* fontSet, IDWriteFontCollection1** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontSet, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, IDWriteFontCollection1** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetFontDownloadQueue(IDWriteFontDownloadQueue** fontDownloadQueue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontDownloadQueue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public HResult GetSystemFontFallback(IDWriteFontFallback** fontFallback) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFallback); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public HResult CreateFontFallbackBuilder(IDWriteFontFallbackBuilder** fontFallbackBuilder) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFallbackBuilder); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult TranslateColorGlyphRun(float baselineOriginX, float baselineOriginY, GlyphRun* glyphRun, GlyphRunDescription* glyphRunDescription, MeasuringMode measuringMode, Matrix* worldToDeviceTransform, uint colorPaletteIndex, IDWriteColorGlyphRunEnumerator** colorLayers) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), baselineOriginX, baselineOriginY, glyphRun, glyphRunDescription, measuringMode, worldToDeviceTransform, colorPaletteIndex, colorLayers); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float grayscaleEnhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, GridFitMode gridFitMode, IDWriteRenderingParams2** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, grayscaleEnhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, gridFitMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, GridFitMode gridFitMode, TextAntialiasMode antialiasMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), glyphRun, transform, renderingMode, measuringMode, gridFitMode, antialiasMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetEudcFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float enhancedContrastGrayscale, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams1** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, enhancedContrastGrayscale, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetSystemFontCollection(IDWriteFontCollection** fontCollection, Bool32 checkForUpdates) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontCollection, checkForUpdates); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public HResult CreateCustomFontCollection(IDWriteFontCollectionLoader* collectionLoader, void* collectionKey, uint collectionKeySize, IDWriteFontCollection** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), collectionLoader, collectionKey, collectionKeySize, fontCollection); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult RegisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult UnregisterFontCollectionLoader(IDWriteFontCollectionLoader* fontCollectionLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontCollectionLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult CreateFontFileReference(ushort* filePath, ulong* lastWriteTime, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), filePath, lastWriteTime, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public HResult CreateCustomFontFileReference(void* fontFileReferenceKey, uint fontFileReferenceKeySize, IDWriteFontFileLoader* fontFileLoader, IDWriteFontFile** fontFile) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFileReferenceKey, fontFileReferenceKeySize, fontFileLoader, fontFile); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult CreateFontFace(FontFaceType fontFaceType, uint numberOfFiles, IDWriteFontFile** fontFiles, uint faceIndex, FontSimulations fontFaceSimulationFlags, IDWriteFontFace** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFaceType, numberOfFiles, fontFiles, faceIndex, fontFaceSimulationFlags, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult CreateRenderingParams(IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public HResult CreateMonitorRenderingParams(IntPtr monitor, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), monitor, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public HResult CreateCustomRenderingParams(float gamma, float enhancedContrast, float clearTypeLevel, PixelGeometry pixelGeometry, RenderingMode renderingMode, IDWriteRenderingParams** renderingParams) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), gamma, enhancedContrast, clearTypeLevel, pixelGeometry, renderingMode, renderingParams); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult RegisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public HResult UnregisterFontFileLoader(IDWriteFontFileLoader* fontFileLoader) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFileLoader); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public HResult CreateTextFormat(ushort* fontFamilyName, IDWriteFontCollection* fontCollection, FontWeight fontWeight, FontStyle fontStyle, FontStretch fontStretch, float fontSize, ushort* localeName, IDWriteTextFormat** textFormat) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), fontFamilyName, fontCollection, fontWeight, fontStyle, fontStretch, fontSize, localeName, textFormat); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public HResult CreateTypography(IDWriteTypography** typography) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), typography); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public HResult GetGdiInterop(IDWriteGdiInterop** gdiInterop) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), gdiInterop); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public HResult CreateTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float maxWidth, float maxHeight, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, maxWidth, maxHeight, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult CreateGdiCompatibleTextLayout(ushort* @string, uint stringLength, IDWriteTextFormat* textFormat, float layoutWidth, float layoutHeight, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, IDWriteTextLayout** textLayout) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), @string, stringLength, textFormat, layoutWidth, layoutHeight, pixelsPerDip, transform, useGdiNatural, textLayout); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult CreateEllipsisTrimmingSign(IDWriteTextFormat* textFormat, IDWriteInlineObject** trimmingSign) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), textFormat, trimmingSign); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult CreateTextAnalyzer(IDWriteTextAnalyzer** textAnalyzer) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), textAnalyzer); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public HResult CreateNumberSubstitution(NumberSubstitutionMethod substitutionMethod, ushort* localeName, Bool32 ignoreUserOverride, IDWriteNumberSubstitution** numberSubstitution) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), substitutionMethod, localeName, ignoreUserOverride, numberSubstitution); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult CreateGlyphRunAnalysis(GlyphRun* glyphRun, float pixelsPerDip, Matrix* transform, RenderingMode renderingMode, MeasuringMode measuringMode, float baselineOriginX, float baselineOriginY, IDWriteGlyphRunAnalysis** glyphRunAnalysis) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), glyphRun, pixelsPerDip, transform, renderingMode, measuringMode, baselineOriginX, baselineOriginY, glyphRunAnalysis); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetSystemFontSet(Bool32 includeDownloadableFonts, IDWriteFontSet2** fontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetSystemFontCollection(Bool32 includeDownloadableFonts, FontFamilyModel fontFamilyModel, IDWriteFontCollection3** fontCollection) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteFactory7*)Unsafe.AsPointer(ref this), includeDownloadableFonts, fontFamilyModel, fontCollection); + } +} + +/// +/// IDWriteFontSet3 +[Guid("7c073ef2-a7f4-4045-8c32-8ab8ae640f90")] +[NativeTypeName("struct IDWriteFontSet3 : IDWriteFontSet2")] +[NativeInheritance("IDWriteFontSet2")] +public unsafe partial struct IDWriteFontSet3 +{ + public static ref readonly Guid IID_IDWriteFontSet3 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0xF2, 0x3E, 0x07, 0x7C, + 0xF4, 0xA7, + 0x45, 0x40, + 0x8C, + 0x32, + 0x8A, + 0xB8, + 0xAE, + 0x64, + 0x0F, + 0x90 + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontSet3)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public IntPtr GetExpirationEvent() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetMatchingFonts(FontProperty* fontProperty, FontAxisValue* fontAxisValues, uint fontAxisValueCount, IDWriteFontSet1** matchingFonts) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontProperty, fontAxisValues, fontAxisValueCount, matchingFonts); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public HResult GetFirstFontResources(IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFilteredFonts(uint* indices, uint indexCount, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), indices, indexCount, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public HResult GetFilteredFonts(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetFilteredFonts(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, IDWriteFontSet1** filteredFontSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, filteredFontSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public HResult GetFilteredFontIndices(FontAxisRange* fontAxisRanges, uint fontAxisRangeCount, Bool32 selectAnyRange, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontAxisRanges, fontAxisRangeCount, selectAnyRange, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetFilteredFontIndices(FontProperty* properties, uint propertyCount, Bool32 selectAnyProperty, uint* indices, uint maxIndexCount, uint* actualIndexCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), properties, propertyCount, selectAnyProperty, indices, maxIndexCount, actualIndexCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public HResult GetFontAxisRanges(uint listIndex, FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontAxisRanges(FontAxisRange* fontAxisRanges, uint maxFontAxisRangeCount, uint* actualFontAxisRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontAxisRanges, maxFontAxisRangeCount, actualFontAxisRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference1** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public HResult CreateFontResource(uint listIndex, IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public HResult CreateFontFace(uint listIndex, IDWriteFontFace5** fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Graphics.DirectWrite.Locality GetFontLocality(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public uint GetFontCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetFontFaceReference(uint listIndex, IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult FindFontFaceReference(IDWriteFontFaceReference* fontFaceReference, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontFaceReference, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public HResult FindFontFace(IDWriteFontFace* fontFace, uint* listIndex, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontFace, listIndex, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetPropertyValues(FontPropertyId propertyID, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), propertyID, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public HResult GetPropertyValues(FontPropertyId propertyID, ushort* preferredLocaleNames, IDWriteStringList** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), propertyID, preferredLocaleNames, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public HResult GetPropertyValues(uint listIndex, FontPropertyId propertyId, Bool32* exists, IDWriteLocalizedStrings** values) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, propertyId, exists, values); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult GetPropertyOccurrenceCount(FontProperty* property, uint* propertyOccurrenceCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), property, propertyOccurrenceCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult GetMatchingFonts(ushort* familyName, FontWeight fontWeight, FontStretch fontStretch, FontStyle fontStyle, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), familyName, fontWeight, fontStretch, fontStyle, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public HResult GetMatchingFonts(FontProperty* properties, uint propertyCount, IDWriteFontSet** filteredSet) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), properties, propertyCount, filteredSet); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public Graphics.DirectWrite.FontSourceType GetFontSourceType(uint fontIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), fontIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public uint GetFontSourceNameLength(uint listIndex) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetFontSourceName(uint listIndex, ushort* stringBuffer, uint stringBufferSize) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontSet3*)Unsafe.AsPointer(ref this), listIndex, stringBuffer, stringBufferSize); + } +} + +/// +/// IDWriteFontFace6 +[Guid("c4b1fe1b-6e84-47d5-b54c-a597981b06ad")] +[NativeTypeName("struct IDWriteFontFace6 : IDWriteFontFace5")] +[NativeInheritance("IDWriteFontFace5")] +public unsafe partial struct IDWriteFontFace6 +{ + public static ref readonly Guid IID_IDWriteFontFace6 + { + [MethodImpl(MethodImplOptions.AggressiveInlining)] + get + { + ReadOnlySpan data = new byte[] { + 0x1B, 0xFE, 0xB1, 0xC4, + 0x84, 0x6E, + 0xD5, 0x47, + 0xB5, + 0x4C, + 0xA5, + 0x97, + 0x98, + 0x1B, + 0x06, + 0xAD + }; + + Debug.Assert(data.Length == Unsafe.SizeOf()); + return ref Unsafe.As(ref MemoryMarshal.GetReference(data)); + } + } + + public static Guid* NativeGuid => (Guid*)Unsafe.AsPointer(ref Unsafe.AsRef(in IID_IDWriteFontFace6)); + + public void** lpVtbl; + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(0)] + public HResult QueryInterface([NativeTypeName("const IID &")] Guid* riid, void** ppvObject) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[0]))((IUnknown*)Unsafe.AsPointer(ref this), riid, ppvObject); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(1)] + [return: NativeTypeName("ULONG")] + public uint AddRef() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[1]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(2)] + [return: NativeTypeName("ULONG")] + public uint Release() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[2]))((IUnknown*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(3)] + public uint GetFontAxisValueCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[3]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(4)] + public HResult GetFontAxisValues(FontAxisValue* fontAxisValues, uint fontAxisValueCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[4]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontAxisValues, fontAxisValueCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(5)] + public Bool32 HasVariations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[5]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(6)] + public HResult GetFontResource(IDWriteFontResource** fontResource) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[6]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontResource); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(7)] + public Bool32 Equals(IDWriteFontFace* fontFace) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[7]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontFace); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(8)] + public HResult GetGlyphImageFormats(ushort glyphId, uint pixelsPerEmFirst, uint pixelsPerEmLast, GlyphImageFormats* glyphImageFormats) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[8]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEmFirst, pixelsPerEmLast, glyphImageFormats); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(9)] + public Graphics.DirectWrite.GlyphImageFormats GetGlyphImageFormats() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[9]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(10)] + public HResult GetGlyphImageData(ushort glyphId, uint pixelsPerEm, GlyphImageFormats glyphImageFormat, GlyphImageData* glyphData, void** glyphDataContext) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[10]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphId, pixelsPerEm, glyphImageFormat, glyphData, glyphDataContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(11)] + public void ReleaseGlyphImageData(void* glyphDataContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[11]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphDataContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(12)] + public HResult GetFontFaceReference(IDWriteFontFaceReference** fontFaceReference) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[12]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontFaceReference); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(13)] + public void GetPanose(Panose* panose) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[13]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), panose); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(14)] + public Graphics.DirectWrite.FontWeight GetWeight() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[14]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(15)] + public Graphics.DirectWrite.FontStretch GetStretch() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[15]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(16)] + public Graphics.DirectWrite.FontStyle GetStyle() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[16]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(17)] + public HResult GetFamilyNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[17]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(18)] + public HResult GetFaceNames(IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[18]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(19)] + public HResult GetInformationalStrings(InformationalStringId informationalStringID, IDWriteLocalizedStrings** informationalStrings, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[19]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), informationalStringID, informationalStrings, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(20)] + public Bool32 HasCharacter(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[20]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(21)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode1* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[21]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(22)] + public Bool32 IsCharacterLocal(uint unicodeValue) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[22]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), unicodeValue); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(23)] + public Bool32 IsGlyphLocal(ushort glyphId) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[23]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphId); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(24)] + public HResult AreCharactersLocal(ushort* characters, uint characterCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[24]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), characters, characterCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(25)] + public HResult AreGlyphsLocal(ushort* glyphIndices, uint glyphCount, Bool32 enqueueIfNotLocal, Bool32* isLocal) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[25]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, enqueueIfNotLocal, isLocal); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(26)] + public Bool32 IsColorFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[26]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(27)] + public uint GetColorPaletteCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[27]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(28)] + public uint GetPaletteEntryCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[28]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(29)] + public HResult GetPaletteEntries(uint colorPaletteIndex, uint firstEntryIndex, uint entryCount, ColorF* paletteEntries) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[29]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), colorPaletteIndex, firstEntryIndex, entryCount, paletteEntries); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(30)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode, GridFitMode* gridFitMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[30]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingParams, renderingMode, gridFitMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(31)] + public void GetMetrics(FontMetrics1* fontMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[31]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(32)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics1* fontMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[32]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(33)] + public void GetCaretMetrics(CaretMetrics* caretMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[33]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), caretMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(34)] + public HResult GetUnicodeRanges(uint maxRangeCount, UnicodeRange* unicodeRanges, uint* actualRangeCount) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[34]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), maxRangeCount, unicodeRanges, actualRangeCount); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(35)] + public Bool32 IsMonospacedFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[35]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(36)] + public HResult GetDesignGlyphAdvances(uint glyphCount, ushort* glyphIndices, int* glyphAdvances, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[36]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvances, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(37)] + public HResult GetGdiCompatibleGlyphAdvances(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, Bool32 isSideways, uint glyphCount, ushort* glyphIndices, int* glyphAdvances) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[37]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, isSideways, glyphCount, glyphIndices, glyphAdvances); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(38)] + public HResult GetKerningPairAdjustments(uint glyphCount, ushort* glyphIndices, int* glyphAdvanceAdjustments) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[38]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphCount, glyphIndices, glyphAdvanceAdjustments); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(39)] + public Bool32 HasKerningPairs() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[39]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(40)] + public HResult GetRecommendedRenderingMode(float fontEmSize, float dpiX, float dpiY, Matrix* transform, Bool32 isSideways, OutlineThreshold outlineThreshold, MeasuringMode measuringMode, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[40]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontEmSize, dpiX, dpiY, transform, isSideways, outlineThreshold, measuringMode, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(41)] + public HResult GetVerticalGlyphVariants(uint glyphCount, ushort* nominalGlyphIndices, ushort* verticalGlyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[41]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphCount, nominalGlyphIndices, verticalGlyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(42)] + public Bool32 HasVerticalGlyphVariants() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[42]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(43)] + public new Graphics.DirectWrite.FontFaceType GetType() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[43]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(44)] + public HResult GetFiles(uint* numberOfFiles, IDWriteFontFile** fontFiles) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[44]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), numberOfFiles, fontFiles); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(45)] + public uint GetIndex() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[45]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(46)] + public Graphics.DirectWrite.FontSimulations GetSimulations() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[46]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(47)] + public Bool32 IsSymbolFont() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[47]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(48)] + public void GetMetrics(FontMetrics* fontFaceMetrics) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[48]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(49)] + public ushort GetGlyphCount() + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[49]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this)); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(50)] + public HResult GetDesignGlyphMetrics(ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[50]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(51)] + public HResult GetGlyphIndices(uint* codePoints, uint codePointCount, ushort* glyphIndices) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[51]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), codePoints, codePointCount, glyphIndices); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(52)] + public HResult TryGetFontTable(uint openTypeTableTag, void** tableData, uint* tableSize, void** tableContext, Bool32* exists) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[52]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), openTypeTableTag, tableData, tableSize, tableContext, exists); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(53)] + public void ReleaseFontTable(void* tableContext) + { + ((delegate* unmanaged[Stdcall])(lpVtbl[53]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), tableContext); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(54)] + public HResult GetGlyphRunOutline(float emSize, ushort* glyphIndices, float* glyphAdvances, GlyphOffset* glyphOffsets, uint glyphCount, Bool32 isSideways, Bool32 isRightToLeft, Graphics.Direct2D.Common.ID2D1SimplifiedGeometrySink* geometrySink) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[54]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, glyphIndices, glyphAdvances, glyphOffsets, glyphCount, isSideways, isRightToLeft, geometrySink); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(55)] + public HResult GetRecommendedRenderingMode(float emSize, float pixelsPerDip, MeasuringMode measuringMode, IDWriteRenderingParams* renderingParams, RenderingMode* renderingMode) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[55]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, measuringMode, renderingParams, renderingMode); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(56)] + public HResult GetGdiCompatibleMetrics(float emSize, float pixelsPerDip, Matrix* transform, FontMetrics* fontFaceMetrics) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[56]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, fontFaceMetrics); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(57)] + public HResult GetGdiCompatibleGlyphMetrics(float emSize, float pixelsPerDip, Matrix* transform, Bool32 useGdiNatural, ushort* glyphIndices, uint glyphCount, GlyphMetrics* glyphMetrics, Bool32 isSideways) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[57]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), emSize, pixelsPerDip, transform, useGdiNatural, glyphIndices, glyphCount, glyphMetrics, isSideways); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(58)] + public HResult GetFamilyNames(FontFamilyModel fontFamilyModel, IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[58]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontFamilyModel, names); + } + + /// + [MethodImpl(MethodImplOptions.AggressiveInlining)] + [VtblIndex(59)] + public HResult GetFaceNames(FontFamilyModel fontFamilyModel, IDWriteLocalizedStrings** names) + { + return ((delegate* unmanaged[Stdcall])(lpVtbl[59]))((IDWriteFontFace6*)Unsafe.AsPointer(ref this), fontFamilyModel, names); + } +} + +#endregion Com Types + +#region Functions +public static unsafe partial class Apis +{ + [DllImport("DWrite", ExactSpelling = true)] + public static extern HResult DWriteCreateFactory(FactoryType factoryType, Guid* iid, IUnknown** factory); + +} +#endregion Functions diff --git a/src/Vortice.Win32/Graphics/Direct2D/PixelFormat.cs b/src/Vortice.Win32/Graphics/Direct2D/PixelFormat.cs index c39184e..cd61353 100644 --- a/src/Vortice.Win32/Graphics/Direct2D/PixelFormat.cs +++ b/src/Vortice.Win32/Graphics/Direct2D/PixelFormat.cs @@ -8,12 +8,12 @@ namespace Win32.Graphics.Direct2D.Common; public partial struct PixelFormat { /// - /// An unkown with to and to . + /// An unkown with to and to . /// public static readonly PixelFormat Unknown = new(Format.Unknown, AlphaMode.Unknown); /// - /// A Premultiplied with to and to . + /// A Premultiplied with to and to . /// public static readonly PixelFormat Premultiplied = new(Format.Unknown, AlphaMode.Premultiplied); diff --git a/src/Vortice.Win32/Graphics/DirectWrite/IDWriteFactoryExtensions.cs b/src/Vortice.Win32/Graphics/DirectWrite/IDWriteFactoryExtensions.cs new file mode 100644 index 0000000..579a03c --- /dev/null +++ b/src/Vortice.Win32/Graphics/DirectWrite/IDWriteFactoryExtensions.cs @@ -0,0 +1,100 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +using System.Runtime.InteropServices.ComTypes; +using Win32.Graphics.Imaging; + +namespace Win32.Graphics.DirectWrite; + +/// +/// A with extensions for the type. +/// +public static unsafe class IDWriteFactoryExtensions +{ + public static ComPtr CreateTextFormat( + this ref IDWriteFactory factory, + ReadOnlySpan fontFamilyName, + float fontSize, + FontWeight fontWeight = FontWeight.Normal, + FontStyle fontStyle = FontStyle.Normal, + FontStretch fontStretch = FontStretch.Normal) + { + using ComPtr textFormat = default; + + fixed (char* fontFamilyNamePtr = fontFamilyName) + { + factory.CreateTextFormat( + (ushort*)fontFamilyNamePtr, + null, + fontWeight, + fontStyle, + fontStretch, + fontSize, + null, + textFormat.GetAddressOf()).ThrowIfFailed(); + + return textFormat.Move(); + } + } + + public static ComPtr CreateTextFormat( + this ref IDWriteFactory factory, + ReadOnlySpan fontFamilyName, + float fontSize, + ReadOnlySpan localeName, + FontWeight fontWeight = FontWeight.Normal, + FontStyle fontStyle = FontStyle.Normal, + FontStretch fontStretch = FontStretch.Normal) + { + using ComPtr textFormat = default; + + fixed (char* fontFamilyNamePtr = fontFamilyName) + { + fixed (char* localeNamePtr = localeName) + { + factory.CreateTextFormat( + (ushort*)fontFamilyNamePtr, + null, + fontWeight, + fontStyle, + fontStretch, + fontSize, + (ushort*)localeNamePtr, + textFormat.GetAddressOf()).ThrowIfFailed(); + } + + return textFormat.Move(); + } + } + + public static ComPtr CreateTextFormat( + this ref IDWriteFactory factory, + ReadOnlySpan fontFamilyName, + IDWriteFontCollection* fontCollection, + float fontSize, + ReadOnlySpan localeName, + FontWeight fontWeight = FontWeight.Normal, + FontStyle fontStyle = FontStyle.Normal, + FontStretch fontStretch = FontStretch.Normal) + { + using ComPtr textFormat = default; + + fixed (char* fontFamilyNamePtr = fontFamilyName) + { + fixed (char* localeNamePtr = localeName) + { + factory.CreateTextFormat( + (ushort*)fontFamilyNamePtr, + fontCollection, + fontWeight, + fontStyle, + fontStretch, + fontSize, + (ushort*)localeNamePtr, + textFormat.GetAddressOf()).ThrowIfFailed(); + } + + return textFormat.Move(); + } + } +} diff --git a/src/Vortice.Win32/Graphics/Gdi/FontSignature.cs b/src/Vortice.Win32/Graphics/Gdi/FontSignature.cs new file mode 100644 index 0000000..5ee62cb --- /dev/null +++ b/src/Vortice.Win32/Graphics/Gdi/FontSignature.cs @@ -0,0 +1,12 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Graphics.Gdi; + +/// FONTSIGNATURE +public partial struct FontSignature +{ + public unsafe fixed uint fsUsb[4]; + + public unsafe fixed uint fsCsb[2]; +} diff --git a/src/Vortice.Win32/Graphics/Gdi/LogFontA.cs b/src/Vortice.Win32/Graphics/Gdi/LogFontA.cs new file mode 100644 index 0000000..0fa9961 --- /dev/null +++ b/src/Vortice.Win32/Graphics/Gdi/LogFontA.cs @@ -0,0 +1,69 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Graphics.Gdi; + +/// LOGFONTA +public partial struct LogFontA +{ + /// + /// The height, in logical units, of the font's character cell or character. + /// The character height value (also known as the em height) is the character cell height value minus the internal-leading value. + /// + public int Height; + + /// + /// The average width, in logical units, of characters in the font. + /// + public int Width; + + /// + /// The angle, in tenths of degrees, between the escapement vector and the x-axis of the device. + /// The escapement vector is parallel to the base line of a row of text. + /// + public int Escapement; + + /// + /// The angle, in tenths of degrees, between each character's base line and the x-axis of the device. + /// + public int Orientation; + + /// + /// The weight of the font in the range 0 through 1000. + /// For example, 400 is normal and 700 is bold. If this value is zero, a default weight is used. + /// + public int Weight; + + /// + /// An italic font if set to TRUE. + /// + public byte Italic; + + /// + /// An underlined font if set to TRUE. + /// + public byte Underline; + + /// + /// A strikeout font if set to TRUE. + /// + public byte StrikeOut; + + /// + /// The character set. + /// + public byte CharSet; + + /// + /// The output precision. The output precision defines how closely the output must match the requested font's height, width, character orientation, escapement, pitch, and font type. + /// + public byte OutPrecision; + + public byte ClipPrecision; + + public byte Quality; + + public byte PitchAndFamily; + + public unsafe fixed sbyte FaceName[32]; +} diff --git a/src/Vortice.Win32/Graphics/Gdi/LogFontW.cs b/src/Vortice.Win32/Graphics/Gdi/LogFontW.cs new file mode 100644 index 0000000..4acd64d --- /dev/null +++ b/src/Vortice.Win32/Graphics/Gdi/LogFontW.cs @@ -0,0 +1,69 @@ +// Copyright © Amer Koleci and Contributors. +// Licensed under the MIT License (MIT). See LICENSE in the repository root for more information. + +namespace Win32.Graphics.Gdi; + +/// LOGFONTW +public partial struct LogFontW +{ + /// + /// The height, in logical units, of the font's character cell or character. + /// The character height value (also known as the em height) is the character cell height value minus the internal-leading value. + /// + public int Height; + + /// + /// The average width, in logical units, of characters in the font. + /// + public int Width; + + /// + /// The angle, in tenths of degrees, between the escapement vector and the x-axis of the device. + /// The escapement vector is parallel to the base line of a row of text. + /// + public int Escapement; + + /// + /// The angle, in tenths of degrees, between each character's base line and the x-axis of the device. + /// + public int Orientation; + + /// + /// The weight of the font in the range 0 through 1000. + /// For example, 400 is normal and 700 is bold. If this value is zero, a default weight is used. + /// + public int Weight; + + /// + /// An italic font if set to TRUE. + /// + public byte Italic; + + /// + /// An underlined font if set to TRUE. + /// + public byte Underline; + + /// + /// A strikeout font if set to TRUE. + /// + public byte StrikeOut; + + /// + /// The character set. + /// + public byte CharSet; + + /// + /// The output precision. The output precision defines how closely the output must match the requested font's height, width, character orientation, escapement, pitch, and font type. + /// + public byte OutPrecision; + + public byte ClipPrecision; + + public byte Quality; + + public byte PitchAndFamily; + + public unsafe fixed ushort FaceName[32]; +} diff --git a/src/Vortice.Win32/UnsafeUtilities.cs b/src/Vortice.Win32/UnsafeUtilities.cs index ee320bd..ec4b74f 100644 --- a/src/Vortice.Win32/UnsafeUtilities.cs +++ b/src/Vortice.Win32/UnsafeUtilities.cs @@ -15,15 +15,9 @@ public static unsafe class UnsafeUtilities where TFrom : unmanaged where TTo : unmanaged { - //Assert(AssertionsEnabled && (SizeOf() == SizeOf())); return CreateReadOnlySpan(in AsReadOnly(in span.GetReference()), span.Length); } - /// - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static T* AsPointer(ref T source) - where T : unmanaged => (T*)Unsafe.AsPointer(ref source); - /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ref readonly TTo AsReadOnly(in TFrom source) @@ -40,19 +34,11 @@ public static unsafe class UnsafeUtilities /// public static ReadOnlySpan CreateReadOnlySpan(in T reference, int length) => MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AsRef(in reference), length); - /// Returns a pointer to the element of the span at index zero. - /// The type of items in . - /// The span from which the pointer is retrieved. - /// A pointer to the item at index zero of . - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static T* GetPointer(this Span span) - where T : unmanaged => AsPointer(ref MemoryMarshal.GetReference(span)); - /// Returns a pointer to the element of the span at index zero. /// The type of items in . /// The span from which the pointer is retrieved. /// A pointer to the item at index zero of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static T* GetPointer(this ReadOnlySpan span) - where T : unmanaged => AsPointer(ref Unsafe.AsRef(in span.GetReference())); + where T : unmanaged => (T*)Unsafe.AsPointer(ref Unsafe.AsRef(in span.GetReference())); } diff --git a/src/Vortice.Win32/Vortice.Win32.csproj b/src/Vortice.Win32/Vortice.Win32.csproj index 2e9b4d2..f0d0cdb 100644 --- a/src/Vortice.Win32/Vortice.Win32.csproj +++ b/src/Vortice.Win32/Vortice.Win32.csproj @@ -14,6 +14,10 @@ + + + + diff --git a/src/samples/01-ClearScreen/Program.cs b/src/samples/01-ClearScreen/Program.cs index 8c74d80..9500194 100644 --- a/src/samples/01-ClearScreen/Program.cs +++ b/src/samples/01-ClearScreen/Program.cs @@ -14,8 +14,10 @@ using static Win32.Graphics.Direct3D.Dxc.Apis; using static Win32.Graphics.Direct3D11.Apis; using static Win32.Graphics.Dxgi.Apis; using static Win32.Graphics.Imaging.Apis; +using static Win32.Graphics.DirectWrite.Apis; using InfoQueueFilter = Win32.Graphics.Direct3D11.InfoQueueFilter; using MessageId = Win32.Graphics.Direct3D11.MessageId; +using Win32.Graphics.DirectWrite; namespace ClearScreen; @@ -72,10 +74,28 @@ public static unsafe class Program //wicBitmapFrameDecode.Get()->CopyPixels(rowPitch, pixels); } + private static void TestD2D1AndDWrite() + { + using ComPtr dwriteFactory = default; + DWriteCreateFactory(FactoryType.Shared, __uuidof(), dwriteFactory.GetIUnknownAddressOf()).ThrowIfFailed(); + + using ComPtr textFormat = + dwriteFactory.Get()->CreateTextFormat( + "Gabriola".AsSpan(), // Font family name. + 72.0f, + fontWeight: FontWeight.Regular, + localeName: "en-us".AsSpan() + ); + + textFormat.Get()->SetTextAlignment(TextAlignment.Center).ThrowIfFailed(); + textFormat.Get()->SetParagraphAlignment(ParagraphAlignment.Center).ThrowIfFailed(); + } + public static void Main() { TestDxc(); TestWic(); + TestD2D1AndDWrite(); using ComPtr factory = default; uint factoryFlags = 0;