This interface can be implemented by either an or an .

The output of the transform will be copied to CPU-accessible memory by the imaging effects system before being passed to the implementation.

If this call fails, the corresponding instance is placed into an error state and fails to draw.

A DIP is 1/96?of an inch. To retrieve the size in device pixels, use the method.

A DIP is 1/96?of an inch. To retrieve the size in device pixels, use the method.

This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match.

Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to EndDraw or Flush.

Starting with Windows?8.1, this method supports block compressed bitmaps. If you are using a block compressed format, the end coordinates of the srcRect parameter must be multiples of 4 or the method returns E_INVALIDARG.

This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion, and will fail if the bitmap formats do not match.

Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to EndDraw or Flush.

All clips and layers must be popped off of the render target before calling this method. The method returns if any clips or layers are currently applied to the render target.

This method does not update the size of the current bitmap. If the contents of the source bitmap do not fit in the current bitmap, this method fails. Also, note that this method does not perform format conversion; the two bitmap formats should match.

If this method is passed invalid input (such as an invalid destination rectangle), can produce unpredictable results, such as a distorted image or device failure.

Calling this method may cause the current batch to flush if the bitmap is active in the batch. If the batch that was flushed does not complete successfully, this method fails. However, this method does not clear the error state of the render target on which the batch was flushed. The failing and tag state will be returned at the next call to EndDraw or Flush.

Starting with Windows?8.1, this method supports block compressed bitmaps. If you are using a block compressed format, the end coordinates of the srcRect parameter must be multiples of 4 or the method returns E_INVALIDARG.

If the bitmap was created without specifying a color context, the returned context is null.

The bitmap used must have been created from a DXGI surface render target, a derived render target, or a device context created from an .

The returned surface can be used with Microsoft Direct3D or any other API that interoperates with shared surfaces. The application must transitively ensure that the surface is usable on the Direct3D device that is used in this context. For example, if using the surface with Direct2D then the Direct2D render target must have been created through or on a device context created on the same device.

If the bitmap was created without specifying a color context, the returned context is null.

The bitmap used must have been created from a DXGI surface render target, a derived render target, or a device context created from an .

The returned surface can be used with Microsoft Direct3D or any other API that interoperates with shared surfaces. The application must transitively ensure that the surface is usable on the Direct3D device that is used in this context. For example, if using the surface with Direct2D then the Direct2D render target must have been created through or on a device context created on the same device.

The bitmap must have been created with the flag specified.

Any memory returned from the Map call is now invalid and may be reclaimed by the operating system or used for other purposes.

The bitmap must have been previously mapped.

A bitmap brush is used to fill a geometry with a bitmap. Like all brushes, it defines an infinite plane of content. Because bitmaps are finite, the brush relies on an "extend mode" to determine how the plane is filled horizontally and vertically.

Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically.

Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically.

This method gets the interpolation mode of a bitmap, which is specified by the enumeration type. represents nearest neighbor filtering. It looks up the bitmap pixel nearest to the current rendering pixel and chooses its exact color. represents linear filtering, and interpolates a color from the four nearest bitmap pixels.

The interpolation mode of a bitmap also affects subpixel translations. In a subpixel translation, linear interpolation positions the bitmap more precisely to the application request, but blurs the bitmap in the process.

Sometimes, the bitmap for a bitmap brush doesn't completely fill the area being painted. When this happens, Direct2D uses the brush's horizontal (SetExtendModeX) and vertical (SetExtendModeY) extend mode settings to determine how to fill the remaining area.

The following illustration shows the results from every possible combination of the extend modes for an : (CLAMP), (WRAP), and D2D1_EXTEND_MIRROR (MIRROR).

dd371139 void ID2D1BitmapBrush::SetExtendModeX([In] D2D1_EXTEND_MODE extendModeX) ID2D1BitmapBrush::SetExtendModeX

This method specifies the bitmap source that this brush uses to paint. The bitmap is not resized or rescaled automatically to fit the geometry that it fills. The bitmap stays at its native size. To resize or translate the bitmap, use the SetTransform method to apply a transform to the brush.

The native size of a bitmap is the width and height in bitmap pixels, divided by the bitmap DPI. This native size forms the base tile of the brush. To tile a subregion of the bitmap, you must generate a new bitmap containing this subregion and use SetBitmap to apply it to the brush.

Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically.

Like all brushes, defines an infinite plane of content. Because bitmaps are finite, it relies on an extend mode to determine how the plane is filled horizontally and vertically.

This method gets the interpolation mode of a bitmap, which is specified by the enumeration type. represents nearest neighbor filtering. It looks up the bitmap pixel nearest to the current rendering pixel and chooses its exact color. represents linear filtering, and interpolates a color from the four nearest bitmap pixels.

The interpolation mode of a bitmap also affects subpixel translations. In a subpixel translation, linear interpolation positions the bitmap more precisely to the application request, but blurs the bitmap in the process.

If both dpiX and dpiY are 0, the dpi of the bitmap will be set to the desktop dpi if the device context is a windowed context, or 96 dpi for any other device context.

An writes to an intermediate texture. It's useful for creating patterns for use with an or caching drawing data that will be used repeatedly.

To write directly to a WIC bitmap instead, use the method. This method returns an that writes to the specified WIC bitmap.

The DPI for the obtained from GetBitmap will be the DPI of the when the render target was created. Changing the DPI of the by calling SetDpi doesn't affect the DPI of the bitmap, even if SetDpi is called before GetBitmap. Using SetDpi to change the DPI of the does affect how contents are rendered into the bitmap: it just doesn't affect the DPI of the bitmap retrieved by GetBitmap.

The DPI for the obtained from GetBitmap will be the DPI of the when the render target was created. Changing the DPI of the by calling SetDpi doesn't affect the DPI of the bitmap, even if SetDpi is called before GetBitmap. Using SetDpi to change the DPI of the does affect how contents are rendered into the bitmap: it just doesn't affect the DPI of the bitmap retrieved by GetBitmap.

If the extend mode enumeration is invalid, this operation is ignored.

If the extend mode enumeration is invalid, this operation is ignored.

The support transform can be used for two different reasons.

• To indicate that a region of its input image is already transparent black. The expanded area will be treated as transparent black.

  This can increase efficiency for rendering bitmaps.

• To increase the size of the input image.

?

?

This can be used to allocate a buffer to receive the color profile bytes associated with the context.

This can be used to allocate a buffer to receive the color profile bytes associated with the context.

If profileSize is insufficient to store the entire profile, profile is zero-initialized before this method fails.

The command list does not include static copies of resources with the recorded set of commands. All bitmaps, effects, and geometries are stored as references to the actual resource and all the brushes are stored by value. All the resource creation and destruction happens outside of the command list. The following table lists resources and how they are treated inside of a command list.

?

The command sink can be implemented by any caller of the API.

If the caller makes any design-time failure calls while a command list is selected as a target, the command list is placed in an error state. The stream call fails without making any calls to the passed in sink.

Sample use:

Class MyCommandSink : public 	
            {	
            public: // All of the  methods implemented here.	
            }; 	
            StreamToMyCommandSink( __in  *pCommandList  )	
            {  hr = ; MyCommandSink *pCommandSink = new MyCommandSink(); hr = pCommandSink ?  : E_OUTOFMEMORY; if (SUCCEEDED(hr)) { // Receive the contents of the command sink streamed to the sink. hr = pCommandList->Stream(pCommandSink); } SafeRelease(&pCommandSink); return hr; }

This method returns if it has already been called on the command list. If an error occurred on the device context during population, the method returns that error. Otherwise, the method returns .

If the Close method returns an error, any future use of the command list results in the same error.

The can be implemented to receive a play-back of the commands recorded in a command list. This interface is typically used for transforming the command list into another format where some degree of conversion between the Direct2D primitives and the target format is required.

The interface does not have any resource creation methods. The resources are logically bound to the Direct2D device on which the was created and will be passed in to the implementation.

Not all methods implemented by are present.

The can be implemented to receive a play-back of the commands recorded in a command list. This interface is typically used for transforming the command list into another format where some degree of conversion between the Direct2D primitives and the target format is required.

The interface does not have any resource creation methods. The resources are logically bound to the Direct2D device on which the was created and will be passed in to the implementation.

Not all methods implemented by are present.

The active at the end of the command list will be returned.

It allows the calling function or method to indicate a failure back to the stream implementation.

The transform will be applied to the corresponding device context.

The unit mode changes the interpretation of units from DIPs to pixels or vice versa.

The clear color is restricted by the currently selected clip and layer bounds.

If no color is specified, the color should be interpreted by context. Examples include but are not limited to:

• Transparent black for a premultiplied bitmap target.
• Opaque black for an ignore bitmap target.
• Containing no content (or white) for a printer page.

DrawText and DrawTextLayout are broken down into glyph runs and rectangles by the time the command sink is processed. So, these methods aren't available on the command sink. Since the application may require additional callback processing when calling DrawTextLayout, this semantic can't be easily preserved in the command list.

Ellipses and rounded rectangles are converted to the corresponding ellipse and rounded rectangle geometries before calling into the DrawGeometry method.

The destinationRectangle parameter defines the rectangle in the target where the bitmap will appear (in device-independent pixels (DIPs)). This is affected by the currently set transform and the perspective transform, if set. If you specify null, then the destination rectangle is (left=0, top=0, right = width(sourceRectangle), bottom = height(sourceRectangle).

The sourceRectangle defines the sub-rectangle of the source bitmap (in DIPs). DrawBitmap clips this rectangle to the size of the source bitmap, so it's impossible to sample outside of the bitmap. If you specify null, then the source rectangle is taken to be the size of the source bitmap.

The perspectiveTransform is specified in addition to the transform on device context.

Because the image can itself be a command list or contain an effect graph that in turn contains a command list, this method can result in recursive processing.

The targetOffset defines the offset in the destination space that the image will be rendered to. The entire logical extent of the image is rendered to the corresponding destination. If you don't specify the offset, 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 opacity mask bitmap must be considered to be clamped on each axis.

If the opacity brush is specified, the primary brush will be a bitmap brush fixed on both the x-axis and the y-axis.

Ellipses and rounded rectangles are converted to the corresponding geometry before being passed to FillGeometry.

If the current world transform is not preserving the axis, clipRectangle is transformed and the bounds of the transformed rectangle are used instead.

The transform changes the state on this render information to specify the compute shader and its dependent resources.

If this call fails, the corresponding instance is placed into an error state and fails to draw.

If this call fails, the corresponding instance is placed into an error state and fails to draw.

If this method fails, fails.

If this call fails, the corresponding instance is placed into an error state and fails to draw.

This interface is created by the effect author from a static factory registered through the ID2D1Factory::RegisterEffect method.

This interface is created by the effect author from a static factory registered through the ID2D1Factory::RegisterEffect method.

This moves resource creation cost to the CreateEffect call, rather than during rendering.

If the implementation fails this call, the corresponding call also fails.

The following example shows an effect implementing an initialize method.

This method is called by the renderer when the effect is within an effect graph that is drawn.

The method will be called:

• If the effect has been initialized but has not previously been drawn.
• If an effect property has been set since the last draw call.
• If the context state has changed since the effect was last drawn.

The method will not otherwise be called. The transforms created by the effect will be called to handle their input and output rectangles for every draw call.

Most effects defer creating any resources or specifying a topology until this call is made. They store their properties and map them to a concrete set of rendering techniques when first drawn.

The vertex shader will be loaded by the CreateVertexBuffer call that accepts the vertex buffer properties.

This structure does not need to be specified if one of the standard vertex shaders is used.

The interface provides the starting point for Direct2D. In general, objects created from a single instance of a factory object can be used with other resources created from that instance, but not with resources created by other factory instances.

Rotation occurs in the plane of the 2-D surface.

This function will also create a new that can be retrieved through .

If the creation properties are not specified, then d2dDevice will inherit its threading mode from dxgiDevice and debug tracing will not be enabled.

This function will also create a new that can be retrieved through .

This function will also create a new that can be retrieved through .

The DXGI device will be specified implicitly through dxgiSurface.

If creationProperties are not specified, the Direct2D device will inherit its threading mode from the DXGI device implied by dxgiSurface and debug tracing will not be enabled.

Formally, if M is the input matrix, this method will return the maximum value of |V * M| / |V| for all vectors V, where |.| denotes length.

This function is called by the GradientMeshPatchFromCoonsPatch function and is not intended to be used directly.

The new device context will not have a selected target bitmap. The caller must create and select a bitmap as the target surface of the context.

Calling this method affects the rendering priority of all device contexts associated with the device. This method can be called at any time, but is not guaranteed to take effect until the beginning of the next frame. The recommended usage is to call this method outside of BeginDraw and EndDraw blocks. Cycling this property frequently within drawing blocks will effectively reduce the benefits of any throttling that is applied.

The new device context will not have a selected target bitmap. The caller must create and select a bitmap as the target surface of the context.

The color glyph cache is used to store color bitmap glyphs and SVG glyphs, enabling faster performance if the same glyphs are needed again. The capacity determines the amount of memory that D2D may use to store glyphs that the application does not already reference. If the application references a glyph using GetColorBitmapGlyphImage or GetSvgGlyphImage, after it has been evicted, this glyph does not count toward the cache capacity.

Any resource created from a device context can be shared with any other resource created from a device context when both contexts are created on the same device.

The application can retrieve the device even if it is created from an earlier render target code-path. The application must use an interface and then call GetDevice. Some functionality for controlling all of the resources for a set of device contexts is maintained only on an object.

If a target is not associated with the device context, target will contain null when the methods returns.

If the currently selected target is a bitmap rather than a command list, the application can gain access to the initial bitmaps created by using one of the following methods:

• CreateHwndRenderTarget
• CreateDxgiSurfaceRenderTarget
• CreateWicBitmapRenderTarget
• CreateDCRenderTarget
• CreateCompatibleRenderTarget

It is not possible for an application to destroy these bitmaps. All of these bitmaps are bindable as bitmap targets. However not all of these bitmaps can be used as bitmap sources for methods.

CreateDxgiSurfaceRenderTarget will create a bitmap that is usable as a bitmap source if the DXGI surface is bindable as a shader resource view.

CreateCompatibleRenderTarget will always create bitmaps that are usable as a bitmap source.

will copy from the to the original bitmap associated with it. will copy from the original bitmap to the .

objects will be locked in the following circumstances:

• BeginDraw has been called and the currently selected target bitmap is a WIC bitmap.
• A WIC bitmap is set as the target of a device context after BeginDraw has been called and before EndDraw has been called.
• Any of the ID2D1Bitmap::Copy* methods are called with a WIC bitmap as either the source or destination.

objects will be unlocked in the following circumstances:

• EndDraw is called and the currently selected target bitmap is a WIC bitmap.
• A WIC bitmap is removed as the target of a device context between the calls to BeginDraw and EndDraw.
• Any of the ID2D1Bitmap::Copy* methods are called with a WIC bitmap as either the source or destination.

Direct2D will only lock bitmaps that are not currently locked.

Calling QueryInterface for will always succeed. will return a device context corresponding to the currently bound target bitmap. GetDC will fail if the target bitmap was not created with the GDI_COMPATIBLE flag set.

will return if there are any outstanding references to the original target bitmap associated with the render target.

Although the target can be a command list, it cannot be any other type of image. It cannot be the output image of an effect.

The new bitmap can be used as a target for SetTarget if it is created with .

Starting with Windows?8.1, the bitmapProperties parameter is optional. When it is not specified, the created bitmap inherits the pixel format and alpha mode from wicBitmapSource. For a list of supported pixel formats and alpha modes, see Supported Pixel Formats and Alpha Modes.

When the bitmapProperties parameter is specified, the value in bitmapProperties->pixelFormat must either be or must match the WIC pixel format in wicBitmapSource.

When bitmapProperties->pixelFormat.alphaMode is set to , the newly created bitmap inherits the alpha mode from wicBitmapSource. When bitmapProperties->pixelFormat.alphaMode is set to , , or , this forces the newly created bitmap to use the specified alpha mode.

The new color context can be used in to initialize the color context of a created bitmap.

When space is , profile and profileSize must be specified. Otherwise, these parameters should be set to null and zero respectively. When the space is , the model field of the profile header is inspected to determine if this profile is sRGB or scRGB and the color space is updated respectively. Otherwise the space remains custom.

The new color context can be used in to initialize the color context of a created bitmap. The model field of the profile header is inspected to determine whether this profile is sRGB or scRGB and the color space is updated respectively. Otherwise the space is custom.

The new color context can be used in to initialize the color context of a created bitmap. The model field of the profile header is inspected to determine whether this profile is sRGB or scRGB and the color space is updated respectively. Otherwise the space is custom.

If the bitmap properties are not specified, the following information is assumed:

• The bitmap DPI is 96.
• The pixel format matches that of the surface.
• The returned bitmap will inherit the bind flags of the DXGI surface.
  • However, only the subset of flags meaningful to Direct2D will be inherited. For example, D3D10_USAGE_DYNAMIC is not compatible with any public Direct2D flags.
• The color context is unknown.
• The alpha mode of the bitmap will be premultiplied (common case) or straight (A8).

If the bitmap properties are specified, the bitmap properties will be used as follows:

• The bitmap DPI will be specified by the bitmap properties.
• If both dpiX and dpiY are 0, the bitmap DPI will be 96.
• The pixel format must be compatible with the shader resource view or render target view of the surface.
• The bitmap options must be compatible with the bind flags of the DXGI surface. However, they may be a subset. This will influence what resource views are created by the bitmap.
• The color context information will be used from the bitmap properties, if specified.

If the created effect is a custom effect that is implemented in a DLL, this doesn't increment the reference count for that DLL. If the application deletes an effect while that effect is loaded, the resulting behavior is unpredictable.

This method linearly interpolates between the color stops. An optional color space conversion is applied post-interpolation. Whether and how this gamma conversion is applied is determined by the pre- and post-interpolation. This method will fail if the device context does not support the requested buffer precision.

In order to get the desired result, you need to ensure that the inputs are specified in the correct color space.

You must always specify colors in straight alpha, regardless of interpolation mode being premultiplied or straight. The interpolation mode only affects the interpolated values. Likewise, the stops returned by will always have straight alpha.

If you specify , then all stops are premultiplied before interpolation, and then un-premultiplied before color conversion.

Starting with Windows?8, the interpolation behavior of this method has changed.

The table here shows the behavior in Windows?7 and earlier.

?

The table here shows the behavior in Windows?8 and later.

?

The image brush can be used to fill an arbitrary geometry, an opacity mask or text.

This sample illustrates drawing a rectangle with an image brush.

	
            CreatePatternBrush( __in  *pDeviceContext, __deref_out  **ppImageBrush )	
            {  hr = ;  *pOldTarget = null; pDeviceContext->GetTarget(&pOldTarget);  *pCommandList = null; hr = pDeviceContext->CreateCommandList(&pCommandList); if (SUCCEEDED(hr)) {    pDeviceContext->SetTarget(pCommandList); hr = RenderPatternToCommandList(pDeviceContext); } pDeviceContext->SetTarget(pOldTarget);  *pImageBrush = null; if (SUCCEEDED(hr)) {         hr = pDeviceContext->CreateImageBrush( pCommandList, D2D1::ImageBrushProperties( D2D1::RectF(198, 298, 370, 470), , ,  ), &pImageBrush ); } // Fill a rectangle with the image brush. if (SUCCEEDED(hr)) { pDeviceContext->FillRectangle( D2D1::RectF(0, 0, 100, 100), pImageBrush); } SafeRelease(&pImageBrush); SafeRelease(&pCommandList); SafeRelease(&pOldTarget); return hr;	
            }

A can store Direct2D commands to be displayed later through or through an image brush.

You can use supported formats in the structure to create bitmaps and render targets. Direct2D doesn't support all DXGI formats, even though they may have some level of Direct3D support by the hardware.

The image bounds don't include multiplication by the world transform. They do reflect the current DPI, unit mode, and interpolation mode of the context. To get the bounds that include the world transform, use .

The returned bounds reflect which pixels would be impacted by calling DrawImage with a target offset of (0,0) and an identity world transform matrix. They do not reflect the current clip rectangle set on the device context or the extent of the context's current target image.

The image bounds reflect the current DPI, unit mode, and world transform of the context. To get bounds which don't include the world transform, use .

The returned bounds reflect which pixels would be impacted by calling DrawImage with the same image and a target offset of (0,0). They do not reflect the current clip rectangle set on the device context or the extent of the context?s current target image.

The image bounds reflect the current DPI, unit mode, and world transform of the context.

The application can retrieve the device even if it is created from an earlier render target code-path. The application must use an interface and then call GetDevice. Some functionality for controlling all of the resources for a set of device contexts is maintained only on an object.

The target can be changed at any time, including while the context is drawing.

The target can be either a bitmap created with the flag, or it can be a command list. Other kinds of images cannot be set as a target. For example, you cannot set the output of an effect as target. If the target is not valid the context will enter the error state.

You cannot use SetTarget to render to a bitmap/command list from multiple device contexts simultaneously. An image is considered ?being rendered to? if it has ever been set on a device context within a BeginDraw/EndDraw timespan. If an attempt is made to render to an image through multiple device contexts, all subsequent device contexts after the first will enter an error state.

Callers wishing to attach an image to a second device context should first call EndDraw on the first device context.

Here is an example of the correct calling order.

pDC1->BeginDraw();	
            pDC1->SetTarget(pImage);	
            // ?	
            pDC1->EndDraw(); pDC2->BeginDraw();	
            pDC2->SetTarget(pImage);	
            // ?	
            pDC2->EndDraw();	
            

Here is an example of the incorrect calling order.

pDC1->BeginDraw();	
            pDC2->BeginDraw(); pDC1->SetTarget(pImage); // ... pDC1->SetTarget(null); pDC2->SetTarget(pImage); // This call is invalid, even though pImage is no longer set on pDC1. // ... pDC1->EndDraw(); // This EndDraw SUCCEEDs.	
            pDC2->EndDraw(); // This EndDraw FAILs 

If a target is not associated with the device context, target will contain null when the methods returns.

If the currently selected target is a bitmap rather than a command list, the application can gain access to the initial bitmaps created by using one of the following methods:

• CreateHwndRenderTarget
• CreateDxgiSurfaceRenderTarget
• CreateWicBitmapRenderTarget
• CreateDCRenderTarget
• CreateCompatibleRenderTarget

It is not possible for an application to destroy these bitmaps. All of these bitmaps are bindable as bitmap targets. However not all of these bitmaps can be used as bitmap sources for methods.

CreateDxgiSurfaceRenderTarget will create a bitmap that is usable as a bitmap source if the DXGI surface is bindable as a shader resource view.

CreateCompatibleRenderTarget will always create bitmaps that are usable as a bitmap source.

will copy from the to the original bitmap associated with it. will copy from the original bitmap to the .

objects will be locked in the following circumstances:

• BeginDraw has been called and the currently selected target bitmap is a WIC bitmap.
• A WIC bitmap is set as the target of a device context after BeginDraw has been called and before EndDraw has been called.
• Any of the ID2D1Bitmap::Copy* methods are called with a WIC bitmap as either the source or destination.

objects will be unlocked in the following circumstances:

• EndDraw is called and the currently selected target bitmap is a WIC bitmap.
• A WIC bitmap is removed as the target of a device context between the calls to BeginDraw and EndDraw.
• Any of the ID2D1Bitmap::Copy* methods are called with a WIC bitmap as either the source or destination.

Direct2D will only lock bitmaps that are not currently locked.

Calling QueryInterface for will always succeed. will return a device context corresponding to the currently bound target bitmap. GetDC will fail if the target bitmap was not created with the GDI_COMPATIBLE flag set.

will return if there are any outstanding references to the original target bitmap associated with the render target.

Although the target can be a command list, it cannot be any other type of image. It cannot be the output image of an effect.

The rendering controls allow the application to tune the precision, performance, and resource usage of rendering operations.

The primitive blend will apply to all of the primitive drawn on the context, unless this is overridden with the compositeMode parameter on the DrawImage API.

The primitive blend applies to the interior of any primitives drawn on the context. In the case of DrawImage, this will be implied by the image rectangle, offset and world transform.

If the primitive blend is anything other than then ClearType rendering will be turned off. If the application explicitly forces ClearType rendering in these modes, the drawing context will be placed in an error state. will be returned from either EndDraw or Flush.

This method will affect all properties and parameters affected by SetDpi and GetDpi. This affects all coordinates, lengths, and other properties that are not explicitly defined as being in another unit. For example:

• SetUnitMode will affect a coordinate passed into ID2D1DeviceContext::DrawLine, and the scaling of a geometry passed into ID2D1DeviceContext::FillGeometry.
• SetUnitMode will not affect the value returned by .

The glyphRunDescription is ignored when rendering, but can be useful for printing and serialization of rendering commands, such as to an XPS or SVG file. This extends , which lacked the glyph run description.

The destinationRectangle parameter defines the rectangle in the target where the bitmap will appear (in device-independent pixels (DIPs)). This is affected by the currently set transform and the perspective transform, if set. If null is specified, then the destination rectangle is (left=0, top=0, right = width(sourceRectangle), bottom = height(sourceRectangle)).

The sourceRectangle parameter defines the sub-rectangle of the source bitmap (in DIPs). DrawBitmap will clip this rectangle to the size of the source bitmap, thus making it impossible to sample outside of the bitmap. If null is specified, then the source rectangle is taken to be the size of the source bitmap.

If you specify perspectiveTransform it is applied to the rect in addition to the transform set on the render target.

You can use the InvalidateEffectInputRectangle method to specify invalidated rectangles for Direct2D to propagate through an effect graph.

If multiple invalid rectangles are requested, the rectangles that this method returns may overlap. When this is the case, the rectangle count might be lower than the count that GetEffectInvalidRectangleCount.

The caller should be very careful not to place a reliance on the required input rectangles returned. Small changes for correctness to an effect's behavior can result in different rectangles being returned. In addition, different kinds of optimization applied inside the render can also influence the result.

This method is used in conjunction with . The D2D1::ComputeFlatteningTolerance helper API may be used to determine the proper flattening tolerance.

If the provided stroke style specifies a stroke transform type other than , then the stroke will be realized assuming the identity transform and a DPI of 96.

This method is used in conjunction with . The D2D1::ComputeFlatteningTolerance helper API may be used to determine the proper flattening tolerance.

If the provided stroke style specifies a stroke transform type other than , then the stroke will be realized assuming the identity transform and a DPI of 96.

This method respects all currently set state (transform, DPI, unit mode, target image, clips, layers); however, artifacts such as faceting may appear when rendering the realizations with a large effective scale (either via the transform or the DPI). Callers should create their realizations with an appropriate flattening tolerance using either D2D1_DEFAULT_FLATTENING_TOLERANCE or ComputeFlatteningTolerance to compensate for this.

Additionally, callers should be aware of the safe render bounds when creating geometry realizations. If a geometry extends outside of [-524,287, 524,287] DIPs in either the X- or the Y- direction in its original (pre-transform) coordinate space, then it may be clipped to those bounds when it is realized. This clipping will be visible even if the realization is subsequently transformed to fit within the safe render bounds.

This method creates an image source which can be used to draw the image.

This method supports images that exceed the maximum texture size. Large images are internally stored within a sparse tile cache.

This API supports the same set of pixel formats and alpha modes supported by CreateBitmapFromWicBitmap. If the GPU does not support a given pixel format, this method will return . This method does not apply adjustments such as gamma or alpha premultiplication which affect the appearance of the image.

This method automatically selects an appropriate storage format to minimize GPU memory usage., such as using separate luminance and chrominance textures for JPEG images.

If the loadingOptions argument is null, D2D uses .

This method creates an image source which can be used to draw the image. This method supports surfaces that use a limited set of DXGI formats and DXGI color space types. Only the below set of combinations of color space types, surface formats, and surface counts are supported:

?

The GPU must also have sufficient support for a pixel format to be supported by D2D. To determine whether D2D supports a format, call IsDxgiFormatSupported.

This API converts YCbCr formats to sRGB using the provided color space type and options. RGBA data is assumed to be in the desired space, and D2D does not apply any conversion.

If multiple surfaces are provided, this method infers whether chroma planes are subsampled (by 2x) from the relative sizes of each corresponding source rectangle (or if the source rectangles parameter is null, the bounds of each surface). The second and third rectangle must each be equal in size to the first rectangle, or to the first rectangle with one or both dimensions scaled by 0.5 (while rounding up).

If provided, the source rectangles must be within the bounds of the corresponding surface. The source rectangles may have different origins. In this case, this method shifts the data from each plane to align with one another.

This method creates an image source which can be used to draw the image. This method supports surfaces that use a limited set of DXGI formats and DXGI color space types. Only the below set of combinations of color space types, surface formats, and surface counts are supported:

?

The GPU must also have sufficient support for a pixel format to be supported by D2D. To determine whether D2D supports a format, call IsDxgiFormatSupported.

This API converts YCbCr formats to sRGB using the provided color space type and options. RGBA data is assumed to be in the desired space, and D2D does not apply any conversion.

If multiple surfaces are provided, this method infers whether chroma planes are subsampled (by 2x) from the relative sizes of each corresponding source rectangle (or if the source rectangles parameter is null, the bounds of each surface). The second and third rectangle must each be equal in size to the first rectangle, or to the first rectangle with one or both dimensions scaled by 0.5 (while rounding up).

If provided, the source rectangles must be within the bounds of the corresponding surface. The source rectangles may have different origins. In this case, this method shifts the data from each plane to align with one another.

This method creates an image source which can be used to draw the image. This method supports surfaces that use a limited set of DXGI formats and DXGI color space types. Only the below set of combinations of color space types, surface formats, and surface counts are supported:

?

The GPU must also have sufficient support for a pixel format to be supported by D2D. To determine whether D2D supports a format, call IsDxgiFormatSupported.

This API converts YCbCr formats to sRGB using the provided color space type and options. RGBA data is assumed to be in the desired space, and D2D does not apply any conversion.

If multiple surfaces are provided, this method infers whether chroma planes are subsampled (by 2x) from the relative sizes of each corresponding source rectangle (or if the source rectangles parameter is null, the bounds of each surface). The second and third rectangle must each be equal in size to the first rectangle, or to the first rectangle with one or both dimensions scaled by 0.5 (while rounding up).

If provided, the source rectangles must be within the bounds of the corresponding surface. The source rectangles may have different origins. In this case, this method shifts the data from each plane to align with one another.

The world bounds reflect the current DPI, unit mode, and world transform of the context. They indicate which pixels would be impacted by calling DrawGradientMesh with the given gradient mesh. They do not reflect the current clip rectangle set on the device context or the extent of the context?s current target.

Any resource created from a device context can be shared with any other resource created from a device context when both contexts are created on the same device.

Any resource created from a device context can be shared with any other resource created from a device context when both contexts are created on the same device.

Before you can render with the DC render target, you must use its BindDC method to associate it with a GDI DC. You do this each time you use a different DC, or the size of the area you want to draw to changes.

If this call fails, the corresponding instance is placed into an error state and will fail to Draw, it will place the context into an error state which can be retrieved through the ID2D1DeviceContext::EndDraw call.

Specifying pixelOptions other than can enable the renderer to perform certain optimizations such as combining various parts of the effect graph together. If this information does not accurately describe the shader, indeterminate rendering artifacts can result.

The vertex shaders associated with the vertex buffer through the vertex shader must have been loaded through the method before this call is made.

If you pass the vertex option , then the method fails unless the blend description is exactly this:

 blendDesc =  { , , , , , , { 1.0f, 1.0f, 1.0f, 1.0f } };

If this call fails, the corresponding instance is placed into an error state and fails to draw.

If blendDescription is null, a foreground-over blend mode is used.

The transform can maintain a reference to this interface for its lifetime. If any properties change on the transform, it can apply these changes to the corresponding drawInfo interface.

This is also used to determine that the corresponding nodes in the graph are dirty.

An effect takes zero or more input images, and has an output image. The images that are input into and output from an effect are lazily evaluated. This definition is sufficient to allow an arbitrary graph of effects to be created from the application by feeding output images into the input image of the next effect in the chain.

The output image can be set as an input to another effect, or can be directly passed into the in order to render the effect.

It is also possible to use QueryInterface to retrieve the same output image.

If the input index is out of range, the input image is ignored.

Most effects do not support a variable number of inputs. Use with the and values to determine the number of inputs supported by an effect.

If the input count is less than the minimum or more than the maximum supported inputs, the call will fail.

If the input count is unchanged, the call will succeed with .

Any inputs currently selected on the effect will be unaltered by this call unless the number of inputs is made smaller. If the number of inputs is made smaller, inputs beyond the selected range will be released.

If the method fails, the existing input and input count will remain unchanged.

An effect takes zero or more input images, and has an output image. The images that are input into and output from an effect are lazily evaluated. This definition is sufficient to allow an arbitrary graph of effects to be created from the application by feeding output images into the input image of the next effect in the chain.

The output image can be set as an input to another effect, or can be directly passed into the in order to render the effect.

It is also possible to use QueryInterface to retrieve the same output image.

This interface is passed to an effect implementation through the method. In order to prevent applications casually gaining access to this interface, and to separate reference counts between the public and private interfaces, it is not possible to call QueryInterface between the and the .

Each call to ID2D1Effect::Initialize will be provided a different interface. This interface tracks resource allocations for the effect. When the effect is released, the corresponding allocations will also be released.

If the is , both dpiX and dpiY will be set to 96.

The created effect does not reference count the DLL from which the effect was created. If the caller unregisters an effect while this effect is loaded, the resulting behavior is unpredictable.