An is abstract. Concrete instances can be created through and .

Images are evaluated lazily. If the type of image passed in is concrete, then the image can be directly sampled from. Other images can act only as a source of pixels and can produce content only as a result of calling .

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.

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.

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

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.

The caller should try to unmap the memory as quickly as is feasable to release occupied DMA aperture memory.

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.

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.

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.

An is a device-dependent resource: your application should create bitmap brushes after it initializes the render target with which the bitmap brush will be used, and recreate the bitmap brush whenever the render target needs recreated. (For more information about resources, see Resources Overview.)

Brush space in Direct2D is specified differently than in XPS and Windows Presentation Foundation (WPF). In Direct2D, brush space is not relative to the object being drawn, but rather is the current coordinate system of the render target, transformed by the brush transform, if present. To paint an object as it would be painted by a WPF brush, you must translate the brush space origin to the upper-left corner of the object's bounding box, and then scale the brush space so that the base tile fills the bounding box of the object.

For more information about brushes, see the Brushes Overview.

When you paint with a brush, it paints in the coordinate space of the render target. Brushes do not automatically position themselves to align with the object being painted; by default, they begin painting at the origin (0, 0) of the render target.

You can "move" the gradient defined by an to a target area by setting its start point and end point. Likewise, you can move the gradient defined by an by changing its center and radii.

To align the content of an to the area being painted, you can use the SetTransform method to translate the bitmap to the desired location. This transform only affects the brush; it does not affect any other content drawn by the render target.

The following illustrations show the effect of using an to fill a rectangle located at (100, 100). The illustration on the left illustration shows the result of filling the rectangle without transforming the brush: the bitmap is drawn at the render target's origin. As a result, only a portion of the bitmap appears in the rectangle.

The illustration on the right shows the result of transforming the so that its content is shifted 50 pixels to the right and 50 pixels down. The bitmap now fills the rectangle.

When the brush transform is the identity matrix, the brush appears in the same coordinate space as the render target in which it is drawn.

When the brush transform is the identity matrix, the brush appears in the same coordinate space as the render target in which it is drawn.

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

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

This method sets the interpolation mode for a bitmap, which is an enum value that is specified in the enumeration type. represents nearest neighbor filtering. It looks up the nearest bitmap pixel 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, bilinear interpolation positions the bitmap more precisely to the application requests, but blurs the bitmap in the process.

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.

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 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, is not compatible with any public Direct2D flags.
• The color context is unknown.

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 a compatible shader 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.

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 following pseudocode illustrates the different cases where a target is set as either a command list or as a bitmap.

• Set the bitmap as the target: In this case, all contents rendered to the bitmap are rasterized. If this bitmap is used somewhere else, it will not be resolution independent and if a transformation like High Quality Scale is used, it will not maintain fidelity.
• Set the command list as the target: In this case, instead of the scene being rasterized, all of the commands are recorded. When the command list is used later for screen drawing using or passed to an XPS print control, the vector content is replayed with no loss of fidelity.
• Drawing a command list to a bitmap target: In this case because the target is a bitmap, the command list is drawn to the bitmap and is no longer resolution independent.

The only way to retain vector content for later playback with full fidelity is to set the target type as a command list. When a bitmap is set as a target, any drawing on that target will get rasterized.

Command lists are a good way to support pattern brushes, because they are capable of retaining fidelity on replay. The desired pattern can be stored as a command list, which can be used to create an image brush. This brush can then be used to paint paths.

The type of brush that supports filling a path with a command list is called an image brush.

The following psuedocode illustrates the process of using a command list with an image brush.

• Because the output of an effect graph is an image, this image can be used to create an image brush, which effectively provides the capability of using an effect as a fill.
• Because the command list is a type of image, vector content can be inserted into an effect graph and can also be tiled or operated on. For example, a large copyright notice can be inserted over a graph with a virtualized image and then encoded.

Compatible render targets are used very often for off-screen rendering to an intermediate bitmap that is later composited with the actual scene. Especially in the case of printing, using compatible render targets will increase the memory footprint because everything will be rasterized and sent to XPS instead of retaining the actual primitives. In this scenario, a developer is better off replacing the compatible render target with an intermediate command list. The following pseudo code illustrates this point.

Direct2D employs a simple model when interoperating with GDI and Direct3D/DXGI APIs. The command list does not record these commands. It instead rasterizes the contents in place and stores them as an . Because the contents are rasterized, these interop points do not maintain high fidelity.

GDI: The command sink interface does not support Get/ReleaseDC() calls. When a call to is made, Direct2D renders the contents of the updated region into a D2D1Bitmap. This will be replayed as an aliased DrawBitmap call with a copy composite mode. To rasterize the bitmap at the correct DPI, at the time of playback of the commands, whatever DPI value is set using the SetDPI() function is used. This is the only case where the sink respects the SetDPI() call.

DX: Direct3D cannot render directly to the command list. To render Direct3D content in this case, the application can call DrawBitmap with the backed by a Direct3D surface.

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; }

Transform nodes are type-less and only define the notion of an object that accepts a number of inputs and is an output. This interface limits a topology to single output nodes.

Transform nodes are type-less and only define the notion of an object that accepts a number of inputs and is an output. This interface limits a topology to single output nodes.

The available channel depth and precision depend on the capabilities of the underlying Microsoft Direct3D device.

If the extend mode enumeration is invalid, this operation is ignored and a debug message is traced.

If the extend mode enumeration is invalid, this operation is ignored and a debug message is traced.

The support transform can be used for two different reasons.

• To indicate that a region of its input image is already transparent black.

  This can increase efficiency for rendering bitmaps.

• To increase the size of the input image.

?

?

Build date: 3/7/2012

The support transform can be used for two different reasons.

• To indicate that a region of its input image is already transparent black.

  This can increase efficiency for rendering bitmaps.

• To increase the size of the input image.

?

?

Build date: 3/7/2012

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.

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

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

This interface is used by a transform implementation to first describe and then indicate changes to the rendering pass that corresponds to the transform.

The input description must be matched correctly by the effect shader code.

If the output precision of the transform is not specified, then it will default to the precision specified on the Direct2D device context. If the default precision on the context is not specified, then the output precision will be the maximum of the precision of the inputs. The maximum of 16bpc UNORM and 16bpc FLOAT is 32bpc FLOAT.

Similar rules apply to the channel depth. The output channel depth will match the maximum of the input channel depths if the channel depth is . If any input buffer is 4-channel, the output buffer will also be 4-channel; otherwise, the intermediate buffer will be allocated with the specified channel depth.

There is no global output channel depth; this is always left to the control of the transforms.

The instruction count may be set according to the number of instructions in the shader. This information is used as a hint when rendering extremely large images. Calling this API is optional, but it may improve performance if you provide an accurate number.

Note??Instructions that occur in a loop should be counted according to the number of loop iterations.

The instruction count may be set according to the number of instructions in the shader. This information is used as a hint when rendering extremely large images. Calling this API is optional, but it may improve performance if you provide an accurate number.

Note??Instructions that occur in a loop should be counted according to the number of loop iterations.

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.

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.

The transform will be applied to the corresponding device context.

The unit mode changes the interpretation of units from device-independent pixels (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.

You must convert ellipses and rounded rectangles to the corresponding ellipse and rounded rectangle geometries before calling into the DrawGeometry method.

,

?

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 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 implements the normal Shatzis methods by implementing . In addition, the caller is passed an ID2D1ComputeRenderInfo to describe the compute pass that the transform should execute.

Transforms are aggregated by effect authors. This interface provides a common interface for implementing the Shantzis rectangle calculations which is the basis for all the transform processing in Direct2D imaging extensions.

The transform implementation must ensure that any pixel shader or software callback implementation it provides honors this calculation.

The transform implementation must regard this method as purely functional. It can base the mapped input and output rectangles on its current state as specified by the encapsulating effect properties. However, it must not change its own state in response to this method being invoked. The DirectImage renderer implementation reserves the right to call this method at any time and in any sequence.

The transform implementation must ensure that any pixel shader or software callback implementation it provides honors this calculation.

The transform implementation must regard this method as purely functional. It can base the mapped input and output rectangles on its current state as specified by the encapsulating effect properties. However, it must not change its own state in response to this method being invoked. The Direct2D renderer implementation reserves the right to call this method at any time and in any sequence.

The transform implements the normal Shatzis methods by implementing . In addition, the caller is passed an ID2D1ComputeRenderInfo to describe the compute pass that the transform should execute.

Transforms are aggregated by effect authors. This interface provides a common interface for implementing the Shantzis rectangle calculations which is the basis for all the transform processing in Direct2D imaging extensions.

The transform implementation must ensure that any pixel shader or software callback implementation it provides honors this calculation.

The transform implementation must regard this method as purely functional. It can base the mapped input and output rectangles on its current state as specified by the encapsulating effect properties. However, it must not change its own state in response to this method being invoked. The DirectImage renderer implementation reserves the right to call this method at any time and in any sequence.

The transform implementation must ensure that any pixel shader or software callback implementation it provides honors this calculation.

The transform implementation must regard this method as purely functional. It can base the mapped input and output rectangles on its current state as specified by the encapsulating effect properties. However, it must not change its own state in response to this method being invoked. The Direct2D renderer implementation reserves the right to call this method at any time and in any sequence.

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

specializes an implementation of the Shantzis calculations to a transform implemented as the source of an effect graph with the data being provided from sytem memory.

specializes an implementation of the Shantzis calculations to a transform implemented as the source of an effect graph with the data being provided from sytem memory.

Provides a render information interface to the source transform to allow it to specify state to the rendering system. This part of the render information interface is shared with the GPU transform.

The implementation of the rasterizer guarantees that adding the renderRect to the targetOrigin does not exceed the bounds of the bitmap.

specializes an implementation of the Shantzis calculations to a transform implemented on the GPU. The information required to specify a pass in the rendering algorithm on a pixel shader is passed to the implementation through the SetRenderInfo method.

specializes an implementation of the Shantzis calculations to a transform implemented on the GPU. The information required to specify a pass in the rendering algorithm on a pixel shader is passed to the implementation through the SetRenderInfo method.

This interface allows a graph of transform nodes to be specified. This interface is passed to to allow an effect implementation to specify a graph of transforms or a single transform.

This equivalent to calling , adding a single node, and connecting all of the node inputs to the effect inputs in order.

This adds a transform node to the transform graph. A node must be added to the transform graph before it can be interconnected in any way.

A transform graph cannot be directly added to another transform graph. Any other kind of interface derived from can be added to the transform graph.

The node must already exist in the graph; otherwise, the call fails with D2DERR_NOT_FOUND.

Any connections to this node will be removed when the node is removed.

After the node is removed, it cannot be used by the interface until it has been added to the graph by AddNode.

The node must already exist in the graph; otherwise, the call fails with D2DERR_NOT_FOUND.

Both nodes must already exist in the graph; otherwise, the call fails with D2DERR_NOT_FOUND.

Used when enough changes to transfoms would make editing of the transform graph inefficient.

If the shader specifies , it must still correctly implement the region of interest calculations in and .

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 this call fails, the corresponding instance is placed into an error state and fails to draw.

Note??The caller should not rely heavily on the input rectangles returned by this structure. They can change due to subtle changes in effect implementations and due to optimization changes in the effect rendering system.

This structure is a subset of that omits fields required to define a vertex layout.

If the D2D1_APPEND_ALIGNED_ELEMENT constant is used for alignedByteOffset, the elements will be packed contiguously for convenience.

If data is larger than bufferSize, this method fails.

After this method returns, the mapped memory from the vertex buffer is no longer accessible by the effect.

If usage is dynamic, the system might return a system memory buffer and copy these vertices into the rendering vertex buffer for each element.

If the initialization data is not specified, the buffer will be uninitialized.

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 number of dimensions in the update must match those of the created texture.

Because a rendering pass is not required, the interface derives from a transform node. This allows it to be inserted into a graph but does not allow an output buffer to be specified.

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

An offset transform is used to offset an input bitmap without having to insert a rendering pass. An offset transform is automatically inserted by an Affine transform if the transform evaluates to a pixel-aligned transform.

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 propertyName is used to cross-correlate the property binding with the registration XML. The propertyName must be present in the XML call or the registration will fail. The property index is used to define the index of the exposed property regardless of the order of the entries in the property binding array or the order of the properties in the registration XML. While the property indices must be contiguous, they do not have to be ordered. All properties must be bound.

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.

If there are no sub-properties, subProperties will be null, and will be returned.

This method returns the number of custom properties on the interface. System properties and sub-properties are part of a closed set, and are enumerable by iterating over this closed set.

This method returns an empty string if index is invalid. If the method returns RESULT_FROM_WIN32(), name will still be filled and truncated.

The value returned by this method can be used to ensure that the buffer size for GetPropertyName is appropriate.

If the property does not exist, the method returns .

If the property does not exist, this method returns D2D1_INVALID_PROPERTY_INDEX. This reserved value will never map to a valid index and will cause null or sentinel values to be returned from other parts of the property interface.

If the property does not exist, the request is ignored and the method returns .

Any error not in the standard set returned by a property implementation will be mapped into the standard error range.

If the property does not exist, the request is ignored and is returned.

Any error not in the standard set returned by a property implementation will be mapped into the standard error range.

If name does not exist, no information is retrieved.

Any error not in the standard set returned by a property implementation will be mapped into the standard error range.

This method returns zero if index does not exist.

If there are no sub-properties, subProperties will be null, and will be returned.

This method returns the number of custom properties on the interface. System properties and sub-properties are part of a closed set, and are enumerable by iterating over this closed set.

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

If the input index is out of range, the returned image will be null.

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 retreive the same output image.

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 retreive the same output image.

The interface is used to create devices, register and unregister effects, and enumerate effects properties. Effects are registered and unregistered globally. The registration APIs are placed on this interface for convenience.

The interface is the starting point for using Direct2D; it's what you use to create other Direct2D resources that you can use to draw or describe shapes.

A factory defines a set of CreateResource methods that can produce the following drawing resources:

• Render targets: objects that render drawing commands.
• Drawing state blocks: objects that store drawing state information, such as the current transformation and antialiasing mode.
• Geometries: objects that represent simple and potentially complex shapes.

To create an , you use one of the CreateFactory methods. You should retain the instance for as long as you use Direct2D resources; in general, you shouldn't need to recreate it when the application is running. For more information about Direct2D resources, see the Resources Overview.

When you create a factory, you can specify whether it is multithreaded or singlethreaded. A singlethreaded factory provides no serialization against any other single threaded instance within Direct2D, so, this mechanism provides a very large degree of scaling on the CPU.

You can also create a multithreaded factory instance. In this case, the factory and all derived objects can be used from any thread and each render target can be rendered to independently. Direct2D serializes calls to these objects, so a single multithreaded Direct2D instance won't scale as well on the CPU as many single threaded instances. However, the resources can be shared within the multithreaded instance.

Note that the qualifier "On the CPU": GPUs generally take advantage of fine-grained parallelism more so than CPUs. For example, multithreaded calls from the CPU might still end up being serialized when being sent to the GPU, however, a whole bank of pixel and vertex shaders will run in parallel to perform the rendering.

You should call this method before calling the GetDesktopDpi method, to ensure that the system DPI is current.

Use this method to obtain the system DPI when setting physical pixel values, such as when you specify the size of a window.

Geometry groups are a convenient way to group several geometries simultaneously so all figures of several distinct geometries are concatenated into one. To create a object, call the CreateGeometryGroup method on the object, passing in the fillMode with possible values of (alternate) and , an array of geometry objects to add to the geometry group, and the number of elements in this array.

Geometry groups are a convenient way to group several geometries simultaneously so all figures of several distinct geometries are concatenated into one. To create a object, call the CreateGeometryGroup method on the object, passing in the fillMode with possible values of (alternate) and , an array of geometry objects to add to the geometry group, and the number of elements in this array.

Like other resources, a transformed geometry the inherits the resource space and threading policy of the factory that created it. This object is immutable.

When stroking a transformed geometry with the DrawGeometry method, the stroke width is not affected by the transform applied to the geometry. The stroke width is only affected by the world transform.

Your application should create render targets once and hold onto them for the life of the application or until the error is received. When you receive this error, you need to recreate the render target (and any resources it created).

When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the error is received. When you receive this error, you need to recreate the render target (and any resources it created).

To write to a Direct3D surface, you obtain an and pass it to the CreateDxgiSurfaceRenderTarget method to create a DXGI surface render target; you can then use the DXGI surface render target to draw 2-D content to the DXGI surface.

A DXGI surface render target is a type of . Like other Direct2D render targets, you can use it to create resources and issue drawing commands.

The DXGI surface render target and the DXGI surface must use the same DXGI format. If you specify the DXGI_FORMAT_UNKOWN format when you create the render target, it will automatically use the surface's format.

The DXGI surface render target does not perform DXGI surface synchronization.

For more information about creating and using DXGI surface render targets, see the Direct2D and Direct3D Interoperability Overview.

To work with Direct2D, the Direct3D device that provides the must be created with the flag.

When you create a render target and hardware acceleration is available, you allocate resources on the computer's GPU. By creating a render target once and retaining it as long as possible, you gain performance benefits. Your application should create render targets once and hold onto them for the life of the application or until the render target's EndDraw method returns the error. When you receive this error, you need to recreate the render target (and any resources it created).

Before you can render with a DC render target, you must use the render target's BindDC method to associate it with a GDI DC. Do this for each different DC and whenever there is a change in the size of the area you want to draw to.

To enable the DC render target to work with GDI, set the render target's DXGI format to and alpha mode to or .

Your application should create render targets once and hold on to them for the life of the application or until the render target's EndDraw method returns the error. When you receive this error, recreate the render target (and any resources it created).

Each call to CreateDevice returns a unique object.

The object is obtained by calling QueryInterface on an or an .