Hubbry Logo
Direct2DDirect2DMain
Open search
Direct2D
Community hub
Direct2D
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Direct2D
Direct2D
Direct2D
View on Wikipedia
from Wikipedia

Direct2D[1] is a 2D vector graphics application programming interface (API) designed by Microsoft and implemented in Windows 10,[2] Windows 8, Windows 7 and Windows Server 2008 R2, and also Windows Vista and Windows Server 2008 (with Platform Update installed).[3]

Direct2D takes advantage of hardware acceleration via the graphics processing unit (GPU) found in compatible graphics cards within personal computer, tablet, smartphone and modern graphical device. It offers high visual quality and fast rendering performance while maintaining full interoperability with classic Win32 graphics APIs such as GDI/GDI+ and modern graphics APIs such as Direct3D.[4]

Overview

[edit]

Direct2D is a native code API based on C++ that can be called by managed code and uses a "lightweight COM" approach[5] just like Direct3D, with minimal amount of abstraction. However, unlike WPF and similarly to GDI/GDI+, Direct2D is an "immediate mode" rendering API with simple BeginDraw/Draw/EndDraw calls; Direct2D has no concept of a "scene" and does not use retained tree structures, and the rendering state is preserved between drawing calls.

Direct2D can minimize CPU usage and utilize hardware rendering on a graphics card with minimum support of Direct3D Feature Level 9 with WDDM 1.1 drivers. Applications can choose to use it exclusively with CPU, the so-called software rendering by using it in conjunction with WARP10 in situations when hardware capability is not available, such as when running within a device with minimal GPU support, under terminal service, Windows session 0, or when graphics rendering is performed in a remote server with the graphical result sent back to the client device. Direct2D performance and memory usage scale linearly with primitive counts in both software and hardware.

Direct2D[6][7] supports high-quality rendering with the following key features:

  • High-quality subpixel text rendering via DirectWrite for both grayscale and ClearType technique
  • Per-primitive antialiasing
  • Bézier geometry draw and fill
  • Rich geometry operations (e.g. Boolean operations, path widening, outlining, etc.)
  • Composite layers
  • Primitive blend modes (e.g. source-over, source-copy, min blends, etc.)
  • Image built-in and custom effects for photo adjustment, graphical and color transform
  • Gradient brush and mesh
  • Command list for command buffering and printing
  • Scalable ink stroke
  • Sprite batch for game development

Direct2D allows full interoperability with GDI, GDI+, and permits rendering to and from a Direct3D surface, as well as to and from a GDI/GDI+ device context (HDC). It can be used effectively together with Windows Imaging Component (WIC) for image encoding/decoding, and with DirectWrite for text formatting and font processing. Such interoperability allows developers to gradually replace critical code paths with Direct2D code without the need to overhaul their entire source code. In Windows 10 timeframe, an Open Source project called Win2D was developed by Microsoft to further simplify the usage of Direct2D and DirectWrite in Universal Windows Platform (UWP) application. Win2D is a highly-efficient WinRT wrapper of Direct2D and DirectWrite designed from the ground up to integrate seamlessly with XAML Canvas control while preserving the power of the underlying graphics subsystem.

Subsequent versions

[edit]

Direct2D 1.1

[edit]

An updated version of Direct2D was launched with Windows 8 in October 2012.[8] It was also backported to Windows 7 SP1 (but not to Windows Vista) via the Windows 7 platform update.[9][10][11] The original version of Direct2D was tied to DirectX 11 (in hardware, up to Direct3D 10.1 is used), whereas this version of Direct2D integrates with DirectX 11.1.[9] Windows 8 also added interoperability between XAML and Direct2D along with Direct3D components, which can be all mixed in an application.[12]

Direct2D 1.2

[edit]

New features were added to Direct2D with Windows 8.1 in October 2013:[13] Geometry realizations,[14] Direct2D effects API,[15][16][17] command list API, multithreading APIs, per-device rendering priority, support for JPEG YCbCr images for smaller memory footprint, and support for block compressed formats (DDS files).

Direct2D 1.3

[edit]

The release of Windows 10 in July 2015 brought important updates and new features to Direct2D such as the performance improvement of rendering scalable text without font rasterization, the ability to download the needed font from the cloud on demand without requiring the font installation step, an optimization for faster image loading and image effect rendering, and a more sophisticated way to apply gradient brush through the use of 2D mesh made of gradient patches. This release also introduced a brand-new API extension to support digital ink, which is highly leveraged by the Microsoft Edge browser as well as the ink canvas XAML control.

Implementation

[edit]

In their 2012 paper on the competing NV path rendering OpenGL extension, Mark Kilgard and Jeff Bolz explain (and criticize) the internals of Direct2D as follows: "Direct2D operates by transforming paths on the CPU and then performing a constrained trapezoidal tessellation of each path. The result is a set of pixel-space trapezoids and additional shaded geometry to compute fractional coverage for the left and right edges of the trapezoids. These trapezoids and shaded geometry are then rasterized by the GPU. The resulting performance is generally better than entirely CPU-based approaches and requires no ancillary storage for multisample or stencil state; Direct2D renders directly into an aliased framebuffer with properly antialiased results. Direct2D’s primary disadvantage is [that] the ultimate performance is determined not by the GPU (doing fairly trivial rasterization) but rather by the CPU performing the transformation and trapezoidal tessellation of each path and Direct3D validation work."[18]

In July 2012, the Windows 8 team posted the following on the blog of Steven Sinofsky: "To improve geometry rendering performance in Windows 8, we focused on reducing the CPU cost associated with tessellation in two ways. First, we optimized our implementation of tessellation when rendering simple geometries like rectangles, lines, rounded rectangles, and ellipses."[19] These common-case optimizations claimed to improve performance in the range of 184% to 438%, depending on the primitive. The post continued: "Second, to improve performance when rendering irregular geometry (e.g. geographical borders on a map), we use a new graphics hardware feature called Target Independent Rasterization, or TIR. TIR enables Direct2D to spend fewer CPU cycles on tessellation, so it can give drawing instructions to the GPU more quickly and efficiently, without sacrificing visual quality. TIR is available in new GPU hardware designed for Windows 8 that supports DirectX 11.1."[19] This was followed by a benchmark using some 15 SVGs, claiming performance improvements in the range of 151% to 523%. The section concluded: "We worked closely with our graphics hardware partners to design TIR. Dramatic improvements were made possible because of that partnership. DirectX 11.1 hardware is already on the market today and we’re working with our partners to make sure more TIR-capable products will be broadly available."[19]

The TIR feature was among those that caused a "war of words" between Nvidia and AMD around December 2012, because Nvidia's Kepler GPU family does not support it, whereas AMD's GCN does.[20] In response to customer demands, an Nvidia support staffer posted that TIR cannot be simply implemented at the driver level, but requires new hardware;[21][22] the Maxwell 2 architecture, introduced in September 2014, is such hardware.[23]

In Windows 8.1, Direct2D can use the Direct3D11 hardware tesselators, but only in conjunction with D2D1_FILL_MODE_ALTERNATE. If another fill mode is used (e.g. D2D1_FILL_MODE_WINDING) then Direct2D falls back to tessellation on the CPU, but still uses TIR for anti-aliasing (if TIR is available). Since hardware tessellation is available in base Direct3D11 (not necessarily 11.1), Microsoft claimed significant performance improvements with Direct2D in Windows 8.1 (vs. Windows 8) on non-TIR hardware.[24]

Uses and performance

[edit]

Internet Explorer 9 and later versions use Direct2D and DirectWrite for improved performance and visual quality.[25][26][27] Direct2D support was added in the alpha version of Firefox 3.7, roughly doubling its rendering speed.[28] (Firefox 4 also added DirectWrite support, but this was made non-default for some fonts in Firefox 7 due to user complaints about the rendering quality.[29] Google Chrome uses its own 2D library called Skia, which in turn renders through ANGLE on Windows.[30]) In Firefox 70.0, on old hardware, Direct2D is disabled on blacklisted old graphics drivers if they lack features and area is blacked out e.g. in Google Maps.[31]

Ars Technica's Peter Bright noted in the summer of 2012 that "most desktop applications don't use Direct2D."[32]

Microsoft Office 2013 supports either Direct2D+DirectWrite or GDI+Uniscribe for display rendering and typography.[33]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Direct2D

View on Grokipedia
from Grokipedia
Direct2D is a hardware-accelerated, immediate-mode 2D graphics application programming interface () developed by for Windows desktop applications, enabling high-performance and high-quality rendering of 2D geometry, bitmaps, and text. It serves as a native-code solution for Win32 developers, targeting scenarios such as enterprise-scale applications, control toolkits, server-side rendering, and integration with Direct3D-based user interfaces. Introduced in in 2009, Direct2D was created to meet growing demands for visual fidelity in digital experiences while leveraging advancements in graphics processing units (GPUs). It builds on for , utilizing Direct3D 10.1 feature levels on and Direct3D 11.1 on and later, with a software rasterizer fallback for systems lacking compatible GPUs. The API supports per-primitive , transparency, alpha blending, and remote rendering over (RDP) starting from , ensuring scalability and compatibility across modern hardware. Direct2D integrates seamlessly with other Microsoft graphics technologies, including interoperability with GDI and GDI+ for legacy content migration, DirectWrite for advanced text rendering, and the Windows Imaging Component (WIC) for image handling. It complements rather than replaces existing APIs like Direct3D for 3D graphics or Windows Presentation Foundation (WPF) for managed code scenarios, offering superior performance over GDI+ in software rendering modes and enabling developers to achieve GPU-accelerated 2D effects such as blurs, shadows, and color management. Subsequent versions, such as Direct2D 1.1 in Windows 8, expanded support to Windows RT and Windows Phone 8.1, enhancing features like high-DPI scaling and advanced color contexts in later updates like Windows 10 Creators Update.

Introduction

Overview

Direct2D is a hardware-accelerated, immediate-mode 2D graphics API developed by for Windows platforms, initially introduced with Windows 7. It enables developers to render 2D geometry, bitmaps, and text with high performance and visual quality, leveraging GPU capabilities for efficient drawing operations. The primary goals of Direct2D include delivering subpixel , transparency, and alpha blending for smooth, high-fidelity visuals, while supporting through integration with for scalable performance across varying GPU hardware. Its design principles emphasize an immediate-mode paradigm, where drawing commands are issued directly without maintaining a retained , promoting simplicity and low overhead in rendering pipelines. Direct2D also integrates seamlessly with DirectWrite for advanced text rendering and the Windows Imaging Component (WIC) for bitmap and image handling, allowing for comprehensive 2D graphics workflows. Within the broader DirectX ecosystem, Direct2D serves as the modern successor to GDI and GDI+, providing a more efficient alternative for contemporary Windows applications that require rich 2D visuals. It bridges 2D and 3D graphics by utilizing DXGI for resource sharing and with , enabling scenarios such as overlaying 2D elements on 3D scenes. The basic workflow involves creating a object for , setting up a render target associated with a device context or surface, issuing drawing commands like paths and fills, and finalizing the frame for presentation.

Development History

Direct2D originated within Microsoft's DirectX team as a response to the evolving demands for high-performance 2D graphics in Windows applications, with its first public announcement occurring at the Professional Developers Conference (PDC) in October 2008, where it was presented alongside previews of Windows 7. The API was developed to address key limitations in established 2D rendering technologies like GDI and GDI+, which struggled with hardware acceleration, resolution-independent vector graphics, advanced antialiasing, and efficient integration with modern display hardware. By building directly atop Direct3D's immediate-mode pipeline, Direct2D aimed to unify 2D and 3D graphics processing, enabling developers to leverage GPU capabilities for visually rich desktop experiences while maintaining compatibility with existing Win32 ecosystems. Development progressed through internal previews and prerelease builds shared with select developers in 2009, culminating in its release to manufacturing (RTM) as a core component of DirectX 11 with on October 22, 2009. This launch marked a significant milestone, as Direct2D was bundled in the Windows SDK and DirectX SDK distributions, allowing broader access for application integration and testing. Microsoft's focus during this period emphasized creating a modern that could support the transition from software-based rendering to hardware-accelerated workflows, particularly for enterprise tools, control libraries, and UI frameworks requiring subpixel-precise output. Initially restricted to Windows 7 and later Windows versions, Direct2D's adoption was constrained by OS compatibility, prompting Microsoft to backport it to Windows Vista SP2 via the Platform Update released on October 27, 2009, which extended support to older installations without full Windows 7 upgrades. This update mitigated early challenges by enabling Direct2D on Vista hardware meeting Direct3D 10.1 requirements, though it required additional installation and did not guarantee uniform performance across legacy systems. Ongoing refinements tied to subsequent Windows releases ensured Direct2D's evolution aligned with platform advancements, solidifying its role in Microsoft's graphics strategy.

Core API

Fundamental Components

The ID2D1Factory interface serves as the entry point for Direct2D applications, enabling the creation of essential resources such as geometries and render targets. It is obtained through the D2D1CreateFactory function, which initializes Direct2D with specified options including debug levels and threading behavior. Direct2D supports two primary threading models via the factory: single-threaded, which offers optimal performance by avoiding overhead but requires all resources to be accessed from one thread; and multi-threaded, which provides built-in for safe access from multiple threads at the cost of serialized calls and reduced CPU scaling. Render targets, represented by the ID2D1RenderTarget interface, are the surfaces where drawing operations occur and are created using . Common types include the ID2D1HwndRenderTarget for rendering directly to a window handle (HWND), the ID2D1DCRenderTarget for interoperability with GDI device contexts (HDC), and bitmap render targets for off-screen rendering to ID2D1Bitmap objects. These render targets support key properties such as DPI scaling, configurable via the SetDpi method to map pixels to device-independent units for high-DPI displays, and antialias modes, set through SetAntialiasMode to enable options like D2D1_ANTIALIAS_MODE_ALIASED for performance or D2D1_ANTIALIAS_MODE_PER_PRIMITIVE for quality. Brushes in Direct2D, all deriving from ID2D1Brush, define the fill or colors and patterns for shapes and are created from a render target. The ID2D1SolidColorBrush applies a uniform color specified by a D2D1_COLOR_F structure, such as opaque black (0.0f, 0.0f, 0.0f, 1.0f). Gradient brushes include the ID2D1LinearGradientBrush, which interpolates colors along a linear axis defined by start and end points with a collection of gradient stops (e.g., at position 0.0 transitioning to green at 1.0), and the ID2D1RadialGradientBrush, which blends colors radially within an specified by , x- and y-radii, and origin offset. The ID2D1BitmapBrush tiles or stretches a image across an area, with extend modes like D2D1_EXTEND_MODE_WRAP or D2D1_EXTEND_MODE_MIRROR controlling edge behavior. Stroke styles, implemented by ID2D1StrokeStyle and created via the factory, customize line appearances for outlines, specifying properties such as line caps (e.g., round or square), line joins (e.g., miter or ), miter limits to cap sharp corners, and dash patterns for dotted or dashed lines. Geometries, represented by ID2D1Geometry interfaces and created by the factory, define the shapes to be drawn. Basic types include ID2D1EllipseGeometry for ellipses via center and radii, ID2D1RectangleGeometry for axis-aligned rectangles, and ID2D1RoundedRectangleGeometry for rectangles with rounded corners specified by corner radii. The ID2D1PathGeometry supports complex outlines composed of segments like lines, arcs, quadratic and cubic Bézier curves, allowing open or closed paths built incrementally via an ID2D1GeometrySink. Geometries provide methods for simplification, such as Simplify to approximate curves with lines or cubic (e.g., using D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES), and tessellation via Tessellate to decompose filled areas into a (ID2D1Mesh) for advanced rendering. Direct2D resources are managed as COM objects following standard creation-usage-release patterns to prevent memory leaks; device-independent resources like geometries are created once via the factory and reused, while device-dependent ones like brushes and render targets must be recreated after device loss (indicated by D2DERR_RECREATE_TARGET) and explicitly released using Release when no longer needed.

Rendering Primitives

Direct2D provides a set of core drawing operations through the ID2D1RenderTarget interface, enabling developers to construct 2D scenes by rendering lines, shapes, and filled regions using and geometries. These primitives form the foundation for rendering, supporting for smooth edges and efficient batching of commands to minimize overhead. Basic drawing methods include DrawLine for rendering straight lines between two points with a specified width, , and optional stroke style to control endpoints and dashing. DrawRectangle and DrawRoundedRectangle outline rectangular shapes, while DrawEllipse and DrawRoundedRectangle handle elliptical and rounded forms, respectively, allowing precise control over properties like width and miter limits. For more complex outlines, DrawGeometry applies to arbitrary ID2D1Geometry objects, such as paths or figures, using the same and style parameters. Corresponding fill methods—FillRectangle, FillEllipse, and FillGeometry—render interiors of these shapes without borders, leveraging , , or for color and variation. These operations are designed for high-performance rendering, with per-primitive to ensure visual quality across different scales. Bitmap handling in Direct2D involves loading raster images via the Windows Imaging Component (WIC), where developers decode files or resources into IWICBitmapSource objects and convert them to ID2D1Bitmap using the render target's CreateBitmapFromWicBitmap method, ensuring compatibility with supported pixel formats like premultiplied BGRA. Once loaded, bitmaps are drawn using DrawBitmap, which scales them to a target rectangle with optional opacity and source clipping for partial rendering. Interpolation modes control scaling quality: D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR for fast, pixel-exact reproduction ideal for UI icons, and D2D1_BITMAP_INTERPOLATION_MODE_LINEAR for smoother bilinear filtering in image enlargement or rotation scenarios. Manipulation extends to creating bitmap brushes for tiling or stretching patterns across shapes, with extend modes like clamp or wrap to handle edges. Clipping and layers enhance primitive rendering by isolating drawing operations within defined regions or applying masks. Layers, created via ID2D1Factory::CreateLayer, are pushed onto the render target stack using PushLayer with D2D1_LAYER_PARAMETERS, specifying an opacity mask (a brush or geometry) and a geometric clip to restrict content to a shape like a star or path. Drawing within the layer applies these constraints cumulatively, and PopLayer restores the previous state, enabling nested effects for complex compositions without permanent alteration to the world transform. Axis-aligned clipping is available via PushAxisAlignedClip for rectangular bounds, offering a lighter alternative for simple overflow control. These mechanisms support opacity modulation and antialiasing preservation during compositing. Transformations modify the coordinate space for all subsequent primitives through the render target's SetTransform method, applying a D2D1_MATRIX_3X2_F structure that represents affine transformations—linear mappings preserving parallelism, including translation (shifting origin), rotation (around a point), uniform or non-uniform scaling, and shearing (skewing axes). Developers compose these by multiplying matrices, with the world transform affecting geometry interpretation, stroke widths (in world units unless specified otherwise), and bitmap placement, but not altering DPI or primitive definitions themselves. This allows efficient scene manipulation without recreating geometries, though complex transforms may impact antialiasing quality. The rendering cycle begins with BeginDraw to prepare the command buffer and initialize the target, followed by a sequence of drawing calls that batch operations for deferred execution. After issuing primitives, Clear may reset the target if needed, and EndDraw flushes the buffer to the surface, returning an HRESULT to indicate success or errors like out-of-memory or device loss, prompting resource recreation. This model ensures for immediate-mode drawing while optimizing GPU submission.

Advanced Features

Effects and Transformations

Direct2D provides a built-in effects API that enables developers to apply advanced image processing operations, such as blurring, shadowing, and color adjustments, through the ID2D1Effect interface. The Gaussian blur effect applies a Gaussian function to soften an image, controlled by the standard deviation property (e.g., 6.0f for moderate blur), and is created using CLSID_D2D1GaussianBlur via ID2D1DeviceContext::CreateEffect. The shadow effect generates drop shadows by combining an input image with an offset and blur, often chained with affine transforms, using CLSID_D2D1Shadow. The color matrix effect modifies pixel colors via a 5x4 transformation matrix applied to RGBA values, with CLSID_D2D1ColorMatrix for operations like channel remapping. The morphology effect thins or thickens edges by eroding or dilating pixels within a kernel sized twice the specified width and height (1–100 DIPs), defaulting to erode mode with CLSID_D2D1Morphology. Effect graphs in Direct2D allow chaining multiple effects into a for complex processing pipelines, where outputs from one effect serve as inputs to another. Input mappings connect ID2D1Image sources, such as bitmaps or prior effect outputs, to an effect's inputs using SetInput or SetInputEffect methods, with indices starting at 0 for the primary input. Rendering occurs by passing the final effect to ID2D1DeviceContext::DrawImage, enabling efficient GPU-accelerated composition. Advanced transformations in Direct2D extend beyond basic 2D affine operations to include color adjustments and 3D perspectives. The color matrix effect supports 3x3 submatrices for RGB hue and saturation changes, such as applying a to cycle hues or scaling channels to desaturate (e.g., averaging RGB for ). Perspective transforms are achieved via custom 4x4 matrices in the 3D transform effect (CLSID_D2D13DTransform), which multiplies image corner vertices [x y z 1] by the matrix for arbitrary 3D warps, including depth projections and s. Helper functions in D2D1::Matrix4x4F facilitate constructing these matrices, such as combining translations and s before setting via D2D1_3DTRANSFORM_PROP_TRANSFORM_MATRIX. Gradient meshes and complex fills in Direct2D support sophisticated color blending for visually rich content. Radial gradients are defined using ID2D1RadialGradientBrush, which interpolates colors along an elliptical gradient with specified stops in an ID2D1GradientStopCollection, originating from a center point with radius extents. Mesh primitives, introduced in Direct2D 1.3, enable smooth color transitions across bicubic patches via ID2D1GradientMesh, created with ID2D1DeviceContext2::CreateGradientMesh from D2D1_GRADIENT_MESH_PATCH arrays. These patches, rendered with DrawGradientMesh, allow for non-uniform, curved-surface gradients ideal for illustrations or UI elements requiring organic color flows. Animation support in Direct2D integrates with the Windows Animation Manager (part of the UIAnimation API) to animate effect properties and transformations over time. Developers use IUIAnimationManager to create storyboards and transitions (e.g., linear or cubic Bézier), applying them to effect values like blur radius or matrix elements via property callbacks, ensuring synchronized, hardware-accelerated updates during rendering loops. Custom effect implementation allows extension of the effects system through the ID2D1EffectImpl interface, enabling developers to define bespoke transforms. Key methods include Initialize for setup and graph construction using ID2D1TransformGraph, PrepareForRender for per-frame adjustments, and SetGraph for dynamic input handling; effects are registered via ID2D1Factory1::RegisterEffectFromString with XML-defined properties and CLSID. This supports advanced scenarios like HLSL shaders or multi-pass processing, integrated seamlessly into effect graphs.

Interoperability Mechanisms

Direct2D facilitates integration with through DXGI surface sharing, allowing shared access to video memory surfaces for efficient 2D-over-3D rendering scenarios. The ID2D1Device interface, introduced for advanced resource management, enables creation of render targets backed by textures via IDXGISurface objects, supporting offscreen rendering where Direct2D content is composed onto surfaces without unnecessary copies. For instance, developers can query an IDXGISurface from a texture using QueryInterface and pass it to ID2D1Factory::CreateDxgiSurfaceRenderTarget to establish a Direct2D render target for drawing 2D elements directly onto the shared surface. Direct2D supports interoperability with Direct3D devices starting from feature level 10.1 and higher, requiring the D3D10_CREATE_DEVICE_BGRA_SUPPORT flag for BGRA format compatibility essential to Direct2D's pixel processing. This enables seamless integration in windowed applications by associating Direct2D render targets with Direct3D swap chains; for example, retrieving a back buffer surface via IDXGISwapChain::GetBuffer allows Direct2D to render directly to the swap chain for presentation. Such mechanisms ensure that 2D overlays, like UI elements or text, can be hardware-accelerated alongside 3D scenes without performance bottlenecks from surface duplication. For compatibility with legacy systems, Direct2D provides HWND and GDI interoperability, allowing rendering directly to window handles and export to GDI bitmaps. The ID2D1Factory::CreateHwndRenderTarget method creates an ID2D1HwndRenderTarget associated with a specific HWND, enabling Direct2D drawing commands to target window surfaces while handling window resizing and occlusion states via methods like CheckWindowState. Additionally, GDI integration uses ID2D1DCRenderTarget to bind a GDI device context (DC) obtained from an HWND, permitting Direct2D content to be drawn into GDI-compatible formats with premultiplied alpha support. Bitmap export to GDI is achieved through ID2D1GdiInteropRenderTarget::GetDC, which provides a GDI DC from a Direct2D render target flagged with D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE, facilitating legacy GDI applications by converting Direct2D bitmaps for further processing. Direct2D supports multithreading through device-level resource management, where ID2D1Device objects allow sharing of immutable resources like bitmaps across threads while requiring separate device contexts per thread for mutable operations. A multithreaded factory, created with D2D1_FACTORY_TYPE_MULTI_THREADED, serializes access to shared resources internally to prevent conflicts, but developers must use synchronization primitives such as ID2D1Multithread::Enter and Leave around Direct3D or DXGI calls like IDXGISwapChain::Present to manage locks and avoid deadlocks. For cross-thread scenarios involving surface sharing, IDXGIKeyedMutex provides keyed synchronization on shared DXGI resources flagged with D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX, ensuring safe alternation between Direct2D and Direct3D rendering. Error handling in interoperability scenarios relies on HRESULT codes to detect failures in surface sharing and resource creation. Common issues include E_OUTOFMEMORY when attempting shared keyed mutex resources on software-emulated devices like WARP, or DXGI_ERROR_INVALID_CALL during surface queue operations if the Direct3D device lacks sharing support. In GDI interop, D2DERR_RECREATE_TARGET signals the need to recreate render targets after device loss, while general surface access errors are checked via SUCCEEDED(hr) patterns in API calls like CreateDxgiSurfaceRenderTarget. Developers must handle these by releasing and reinitializing resources to maintain stability in composite rendering pipelines.

Version History

Direct2D 1.0

Direct2D 1.0 was released in October 2009 as part of and the 11 runtime, marking the introduction of a hardware-accelerated 2D graphics API designed for high-performance rendering. The initial API surface centered on core components such as the ID2D1Factory interface for resource creation, ID2D1RenderTarget for managing drawing contexts and output surfaces, and basic geometry objects like paths, ellipses, and rectangles to define shapes and paths. These elements enabled developers to build immediate-mode 2D graphics pipelines integrated with for composition, supporting brushes for fills and strokes while emphasizing device-independent pixels for scalability across displays. A key innovation in Direct2D 1.0 was its hardware-accelerated per-primitive , which applied gamma-correct blending to produce smoother edges on curves and lines without sacrificing performance, leveraging GPU capabilities where available with software fallback on unsupported hardware. Additionally, integration with DirectWrite provided high-quality subpixel text rendering, utilizing technology for enhanced readability in antialiased text layouts, allowing seamless drawing of formatted text strings directly onto render targets. These features addressed limitations in prior APIs like GDI by prioritizing visual fidelity and efficiency in modern applications. At launch, Direct2D 1.0 had notable limitations, including a single-threaded factory model that restricted concurrent access without careful synchronization, the absence of device contexts for advanced resource management, and only basic built-in effects such as simple blurs and color adjustments without a comprehensive effects framework. Early documentation and sample code were provided in the Windows SDK 7.0, including tutorials for creating render targets and drawing primitives, which facilitated adoption in first-party Microsoft applications like Windows Live Essentials for UI rendering. Regarding backward compatibility, Direct2D 1.0 offered no native support on operating systems prior to , requiring the Platform Update for SP2 or earlier versions to enable functionality, though full hardware acceleration depended on compatible runtimes.

Direct2D 1.1

Direct2D 1.1 was introduced alongside on October 26, 2012, marking a significant evolution from version 1.0 by emphasizing scalability, multithreading, and tighter hardware integration for modern applications. A key architectural change involved the addition of the ID2D1Device and ID2D1DeviceContext interfaces, which separate resource management from rendering commands to enable more efficient handling of resources and support for advanced scenarios like deferred rendering. The ID2D1Device acts as a container for Direct2D resources tied to a specific Direct3D device, while the ID2D1DeviceContext serves as the primary rendering interface, inheriting from ID2D1RenderTarget but offering greater flexibility for command batching and context switching. This design reduces overhead in resource creation and destruction, particularly beneficial for applications with frequent updates. Among the new features, Direct2D 1.1 enhanced multithreading capabilities through the ID2D1Factory1 interface and support for multithreaded factories created via D2D1_FACTORY_TYPE_MULTI_THREADED. This allows safe concurrent access to shared resources across threads with automatic , minimizing contention while enabling developers to use separate device contexts per thread for mutable elements like brushes and text layouts. Additionally, improved DPI handling was introduced with methods like GetDesktopDpi on the factory and SetDpi on the device context, facilitating automatic scaling of the logical to match high-resolution displays without manual recalculations. For efficient bitmap drawing, the device context supports batched operations via repeated DrawImage calls within a single begin/end draw sequence, optimizing performance for scenarios involving multiple image renders such as UI elements or animations. Direct2D 1.1 previewed advanced effects through the introduction of color contexts via ID2D1ColorContext and basic support for image effects APIs, allowing developers to apply transformations like color adjustments directly in the rendering pipeline. These effects leverage GPU acceleration for high-quality processing, with early implementations focusing on and color spaces. Integration with 11.1 was deepened through enhanced DXGI support, enabling seamless resource sharing and management for lower-latency rendering on hardware. Performance improvements in Direct2D 1.1 targeted dynamic content by reducing CPU overhead in command submission, as the device defers flushing to the GPU until explicitly needed, ideal for real-time updates in interactive applications. for complex paths was enhanced through optimized in the device , allowing finer control over triangle generation and rasterization for smoother rendering of intricate shapes without excessive CPU involvement. These optimizations contributed to better frame rates in scenarios with frequent path redraws. Adoption of Direct2D 1.1 was prominent in Windows 8's , powering Metro-style (now ) applications with hardware-accelerated rendering for elements like live tiles, charms, and immersive app surfaces. It also extended to and , ensuring consistent 2D graphics performance across the ecosystem.

Direct2D 1.2

Direct2D 1.2 was released in October 2013 as part of , building on the device-based architecture introduced in the previous version to enhance rendering efficiency and support advanced 2D graphics scenarios. A key addition is geometry realizations, which allow applications to cache complex shapes as device-dependent objects for faster repeated rendering without the memory overhead of bitmap rasterization. This feature is particularly useful for scenarios involving frequent draws of intricate paths or shapes, improving performance in dynamic UIs. The version expands the API surface with command lists via the ID2D1CommandList interface, enabling developers to record sequences of draw calls for later replay, which facilitates efficient rendering pipelines such as printing or multithreaded composition. It also provides a comprehensive effects framework, incorporating over 30 built-in effects across categories like color adjustment, blending, and image filtering, allowing high-quality post-processing directly in the rendering pipeline. These effects leverage Direct3D 11.2 for hardware acceleration, supporting complex graph-based compositions for tasks like shadow generation or color grading. Enhancements in Direct2D 1.2 include improved bitmap source APIs, such as native support for formats and block-compressed DDS textures, which reduce memory usage and accelerate loading for image-heavy applications. Additionally, per-device rendering priority settings allow apps to designate low-priority contexts for background tasks, optimizing on multi-monitor setups. For accessibility, the better accommodates high-contrast themes through enhanced color and alpha mode handling in render targets. Developer resources for Direct2D 1.2 are integrated into the Windows SDK 8.1, featuring updated samples that demonstrate geometry realizations, effects chaining, and command list usage in real-world scenarios like photo editors. Integration with XAML is streamlined via the new SwapChainPanel control, enabling hybrid apps to embed Direct2D content seamlessly within declarative UIs for mixed native and managed codebases. The version maintains full backward compatibility with Direct2D 1.0 and 1.1 applications, ensuring existing codebases run unchanged on while accessing new features through conditional compilation.

Direct2D 1.3 and Subsequent Updates

The initial release of in July 2015 included updates to Direct2D with performance improvements in rendering scalable text and bitmaps, as well as support for advanced color spaces. Direct2D 1.3 was introduced with the Anniversary Update in August 2016, building upon 11 for enhanced stability and performance in rendering operations, allowing better integration with modern graphics hardware while maintaining compatibility with earlier feature levels. A major addition in Direct2D 1.3 was the introduction of SVG parsing and rendering capabilities, enabling developers to load and draw directly without third-party libraries. This support, available starting with the Creators Update, includes parsing of SVG documents and rendering them as Direct2D geometry or images, though it excludes certain advanced SVG features like text elements for simplicity and performance reasons. Direct2D 1.3 also enhanced through the color management effect, which no longer requires traditional ICC profiles; instead, it supports DXGI color spaces or custom color context definitions for more flexible transformations between color spaces. These improvements, rolled out in the Creators Update, facilitate better handling of wide color gamuts and content without relying on external profile files. Further advancements in advanced color support, including provisions for HDR displays, were integrated in the Fall Creators Update (version 1709) in October 2017, aligning Direct2D with broader Windows color pipeline changes. Subsequent updates to Direct2D have focused on incremental enhancements through annual Windows SDK releases, with no major version increments beyond 1.3 as of 2025. In , Direct2D benefits from DXGI-level support for displays, allowing smoother rendering on compatible hardware by adapting to dynamic frame rates without tearing. These updates include ongoing bug fixes and minor refinements, such as improved interoperability with evolving components, delivered via SDK versions up to 10.0.26100. Third-party libraries like Microsoft.Graphics.Win2D provide wrappers around 1.3 APIs, simplifying usage in UWP and WinUI applications; version 1.3.0 of this library was released in October 2024, emphasizing ease-of-use for immediate-mode 2D rendering. Looking ahead, Direct2D maintenance emphasizes stability and alignment with 12 through interoperation mechanisms, without anticipated major version releases, as the API remains a core component of Windows ecosystem as of late 2025.

Implementation Details

Architecture and Hardware Acceleration

Direct2D operates as a user-mode library layered atop Direct3D, specifically utilizing Direct3D 10.1 feature levels on Windows 7 and Direct3D 11.1 on Windows 8 and later, to enable hardware-accelerated 2D rendering while providing a software rasterizer fallback for unsupported hardware configurations. This architecture allows Direct2D to abstract complex Direct3D operations, presenting an immediate-mode API for drawing 2D primitives, bitmaps, and text, with internal optimizations for batching and efficiency. The rendering pipeline in Direct2D begins with drawing commands issued between BeginDraw and EndDraw calls on a render target or device context, which internally buffers these commands and state changes into command lists compatible with . For geometries, Direct2D performs to convert complex shapes into polygons, generating vertex and index buffers that are cached as geometry realizations—introduced in Direct2D 1.2—to avoid redundant processing for static or infrequently changing paths under varying transforms. These buffers are then submitted to the device for rasterization, enabling efficient GPU execution of the 2D scene. Hardware acceleration is achieved through Direct3D's GPU capabilities, where shaders handle per-primitive via (MSAA), as well as effects like blurs and color transformations, and advanced blending modes for layers. If the underlying hardware lacks sufficient Direct3D feature level support (e.g., below 9.3 for certain operations), Direct2D seamlessly falls back to its high-performance software rasterizer, ensuring consistent rendering quality without hardware dependency. Direct2D's memory model distinguishes between device-independent resources, such as geometries, which reside in system RAM on the CPU for cross-device portability, and device-dependent resources like render targets and brushes, which allocate in VRAM on the GPU when is available or in system RAM otherwise. To avoid garbage collection overhead, Direct2D eschews automatic or pooling; instead, developers must manually recreate resources upon device loss events, signaled via errors like D2DERR_RECREATE_TARGET, promoting predictable memory usage and minimizing runtime stalls. The threading architecture enforces single-threaded rendering per render target or device context to maintain state consistency, but supports multi-threaded resource creation through factories configured with the D2D1_FACTORY_TYPE_MULTI_THREADED option, allowing concurrent and generation from worker threads. For enhanced parallelism in path tessellation, Direct2D 1.1 and later provide the D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTI_THREADED_OPTIMIZATIONS , distributing computation across logical cores on multi-core systems, while multi-device support enables separate factories and devices for isolated rendering contexts, such as offscreen surfaces. Debugging the Direct2D is facilitated by the Direct2D Debug Layer, a separate DLL (d2d1debug.dll) that intercepts calls to report errors, warnings, and diagnostics, such as invalid parameters or suboptimal layer usage, with configurable verbosity levels including breakpoints for severe issues like threading violations. Additionally, Visual Studio's Graphics Diagnostics tools, integrated for applications, allow capture and inspection of the underlying frames, enabling frame analysis, shader debugging, and resource state examination to troubleshoot Direct2D rendering artifacts or bottlenecks.

Integration with Windows Platforms

Direct2D provides native support for 2D graphics rendering starting with , as well as with 2 (SP2) and the Platform Update installed, and or Server 2008 with SP2 and the Platform Update. In (UWP) applications, Direct2D integrates with XAML-based user interfaces through interoperation surfaces like SurfaceImageSource for event-driven rendering or SwapChainPanel for high-performance scenarios, allowing developers to render 2D content alongside XAML elements. For WinUI applications, particularly in desktop contexts, XAML islands enable the embedding of WinUI controls into existing Win32 applications, with Direct2D accessible via libraries like Win2D for seamless GPU-accelerated 2D drawing in XAML environments. applications leveraging Direct2D must be packaged as UWP or using the MSIX format to meet distribution requirements and ensure compatibility across devices. For compatibility on systems with older or incompatible GPUs, Direct2D employs a software fallback using the Windows Advanced Rasterization Platform (WARP), a CPU-based renderer that maintains functionality without when D3D devices fail or return errors like D2DERR_RECREATE_TARGET. Updates to Direct2D, including platform enhancements and bug fixes, are delivered through for runtime components on supported operating systems, while developers obtain the latest headers, libraries, and tools via the Windows SDK installations. Deployment of Direct2D-based applications involves dynamic loading of the core d2d1.dll from the system directory (e.g., System32), where the DLL version aligns with the installed Windows version or applied updates, such as the Platform Update for Windows 7 to enable Direct2D 1.1 features. For applications requiring specific Direct2D versions alongside system defaults, side-by-side assemblies can be manifested to isolate dependencies, though core Direct2D functionality relies on the shared system DLL to avoid redistribution issues. In UWP environments, Direct2D operates within the AppContainer sandbox, which isolates the application process by restricting access to kernel objects, files, and devices, thereby enhancing security against unauthorized system interactions or privilege escalations. Developers must implement input validation for parameters passed to Direct2D effects and render targets to mitigate risks like buffer overflows or invalid state errors that could lead to application instability. Tooling for Direct2D development includes integration within the Windows SDK, which provides C++ headers (d2d1.h) and libraries (d2d1.lib) for native applications, accessible through 's Win32 and UWP project templates that support graphics initialization. For managed languages like C#, the Win2D NuGet package offers a high-level wrapping Direct2D, installable via the Package Manager in , and compatible with UWP, WinUI, and desktop projects as of 2025. Visual Studio 2022 and later versions include built-in templates for -enabled projects, facilitating quick setup for Direct2D rendering pipelines without manual configuration.

Applications and Performance

Typical Use Cases

Direct2D is widely employed in rendering for native Windows applications, particularly in Win32 and WPF environments, where it enables the creation of custom controls, vector-based icons, and fluid animations with hardware-accelerated performance superior to legacy GDI systems. Developers leverage its immediate-mode API to draw high-quality 2D geometry, bitmaps, and text directly into application windows, facilitating modern, responsive interfaces in enterprise-scale software and control libraries. In gaming and media applications, Direct2D supports efficient 2D overlays integrated with scenes, such as heads-up displays (HUDs), particle effects, and user interfaces in both full-scale titles and indie games. Its ability to render text and shapes out-of-order while batching draw calls ensures smooth performance for real-time elements like menus and status indicators without compromising pipelines. For productivity tools, Direct2D provides precise capabilities essential for diagram editors, charting libraries, and image manipulation software, allowing for scalable drawings and effects like transparency and . Sample implementations, such as photo viewers and editors, demonstrate its use in applying effects like to bitmaps for professional-grade adjustments. Additionally, third-party frameworks like JUCE incorporate Direct2D for rendering in multimedia applications, such as audio editors and visualizers, enabling cross-platform compatibility with Windows-specific high-performance graphics.

Performance Benchmarks and Optimizations

Direct2D delivers significantly enhanced rendering performance compared to legacy APIs like GDI+, particularly in hardware-accelerated scenarios where it leverages the GPU for complex 2D graphics operations. In software rendering mode, Direct2D also provides substantially better throughput than GDI+ while maintaining comparable visual fidelity to GDI. These gains stem from Direct2D's integration with Direct3D, enabling efficient GPU utilization for tasks such as antialiasing, blending, and geometry processing, which can achieve frame times under 16 milliseconds on modern hardware to support 60 FPS rendering. Key optimization techniques focus on minimizing CPU involvement and maximizing . Developers should batch drawing commands within BeginDraw and EndDraw calls to reduce overhead, rather than issuing frequent Flush operations that force immediate GPU submission. Resource reuse is critical; , brushes, and geometries should be created once and recycled across frames, as repeated allocations incur high CPU costs due to hardware synchronization. To further optimize, employ atlases for multiple small images, ensuring each exceeds 4 KB to avoid fragmentation, and prefer specialized draw methods like DrawRectangle over generic DrawGeometry for lower vertex processing demands. Enabling multi-threaded optimizations via D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTI_THREADED_OPTIMIZATIONS allows parallel geometry realization, beneficial for complex scenes. Common bottlenecks include geometry creation and VRAM constraints from inefficient bitmap management. Excessive primitive generation, such as dynamic path computations, can overload the CPU, while allocating numerous small bitmaps leads to VRAM waste and increased garbage collection. To diagnose these, use tools like GPUView for tracing GPU queue activity and DMA buffer performance, or XPerf from the Windows Performance Toolkit to measure per-frame CPU and GPU times. Scene complexity analysis—by varying render target size—helps distinguish fill-rate limits (pixel-bound) from vertex-bound issues. Updates in Direct2D 1.1 introduced command lists via ID2D1CommandList, enabling deferred rendering and multithreading to reduce latency in multi-threaded applications. enhancements further improved overall rendering efficiency, including better support for high-dynamic-range content and scalable text, contributing to smoother performance in modern display pipelines. For scalability, Direct2D handles high-resolution outputs like 4K by leveraging DXGI flip models for efficient presentation across setups, minimizing copy operations and supporting variable refresh rates.

References

  1. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-overview
  2. https://learn.microsoft.com/en-us/windows/win32/learnwin32/overview-of-the-windows-graphics-architecture
  3. https://learn.microsoft.com/en-us/windows/uwp/gaming/directx-feature-improvements-for-windows-phone-8-1
  4. https://learn.microsoft.com/en-us/windows/win32/direct2d/what-s-new-in-direct2d-for-windows-8-consumer-preview
  5. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-portal
  6. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-and-direct3d-interoperation-overview
  7. https://learn.microsoft.com/en-us/windows/win32/direct2d/getting-started-with-direct2d
  8. https://learn.microsoft.com/en-us/shows/pdc-pdc08/pc18
  9. https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/june/introducing-direct2d
  10. https://www.microsoft.com/en-us/download/details.aspx?id=6812
  11. https://blogs.windows.com/windowsexperience/2009/10/27/announcing-final-releases-of-platform-update-for-windows-vista-technologies/
  12. https://learn.microsoft.com/en-us/windows/win32/win7ip/platform-update-for-windows-vista-overview
  13. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1factory
  14. https://learn.microsoft.com/en-us/windows/win32/direct2d/multi-threaded-direct2d-apps
  15. https://learn.microsoft.com/en-us/windows/win32/direct2d/render-targets-overview
  16. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1rendertarget
  17. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-setdpi
  18. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-brushes-overview
  19. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1solidcolorbrush
  20. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1lineargradientbrush
  21. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1radialgradientbrush
  22. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1bitmapbrush
  23. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1strokestyle
  24. https://learn.microsoft.com/en-us/windows/win32/direct2d/id2d1factory-createstrokestyle
  25. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-geometries-overview
  26. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nn-d2d1-id2d1geometry
  27. https://learn.microsoft.com/en-us/windows/win32/direct2d/resources-and-resource-domains
  28. https://learn.microsoft.com/en-us/windows/win32/direct2d/the-direct2d-api
  29. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-drawline
  30. https://learn.microsoft.com/en-us/windows/win32/direct2d/id2d1rendertarget-drawrectangle
  31. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-drawgeometry
  32. https://learn.microsoft.com/en-us/windows/win32/direct2d/how-to-load-a-direct2d-bitmap-from-a-file
  33. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-drawbitmap%28id2d1bitmap_constd2d1_rect_f__float_d2d1_bitmap_interpolation_mode_constd2d1_rect_f_%29
  34. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/ne-d2d1-d2d1_bitmap_interpolation_mode
  35. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-layers-overview
  36. https://learn.microsoft.com/en-us/windows/win32/direct2d/how-to-clip-with-layers
  37. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-pushlayer%28constd2d1_layer_parameters__id2d1layer%29
  38. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-transforms-overview
  39. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1rendertarget-enddraw
  40. https://learn.microsoft.com/en-us/windows/win32/direct2d/effects-overview
  41. https://learn.microsoft.com/en-us/windows/win32/direct2d/color-matrix
  42. https://learn.microsoft.com/en-us/windows/win32/direct2d/morphology
  43. https://learn.microsoft.com/en-us/windows/win32/direct2d/3d-transform
  44. https://learn.microsoft.com/en-us/windows/win32/direct2d/how-to-create-a-radial-gradient-brush
  45. https://learn.microsoft.com/en-us/windows/win32/api/d2d1_3/nn-d2d1_3-id2d1gradientmesh
  46. https://learn.microsoft.com/en-us/visualstudio/releases/2010/vs2010-SP1-vs
  47. https://learn.microsoft.com/en-us/windows/win32/uianimation/introducing-windows-animation-manager
  48. https://learn.microsoft.com/en-us/windows/win32/direct2d/custom-effects
  49. https://learn.microsoft.com/en-us/windows/win32/direct3darticles/surface-sharing-between-windows-graphics-apis
  50. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-and-gdi-interoperation-overview
  51. https://learn.microsoft.com/en-us/windows/win32/api/d2d1/nf-d2d1-id2d1factory-createhwndrendertarget%28constd2d1_render_target_properties_constd2d1_hwnd_render_target_properties_id2d1hwndrendertarget%29
  52. https://learn.microsoft.com/en-us/windows/win32/direct3d11/dx11-whats-new
  53. https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/september/drawing-with-direct2d
  54. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-and-directwrite
  55. https://learn.microsoft.com/en-us/archive/msdn-magazine/2013/may/windows-with-c-introducing-direct2d-1-1
  56. https://learn.microsoft.com/en-us/windows/win32/direct3darticles/platform-update-for-windows-7
  57. https://learn.microsoft.com/en-us/windows/win32/direct2d/id2d1geometry-tessellate
  58. https://learn.microsoft.com/en-us/lifecycle/products/windows-81
  59. https://learn.microsoft.com/en-us/windows/win32/direct2d/geometry-realizations-overview
  60. https://learn.microsoft.com/en-us/windows/win32/direct2d/improving-direct2d-performance
  61. https://learn.microsoft.com/en-us/windows/win32/api/d2d1_1/nn-d2d1_1-id2d1commandlist
  62. https://learn.microsoft.com/en-us/windows/win32/direct2d/built-in-effects
  63. https://learn.microsoft.com/en-us/windows/win32/direct2d/jpeg-ycbcr-support
  64. https://learn.microsoft.com/en-us/windows/win32/direct2d/block-compressed-formats
  65. https://learn.microsoft.com/en-us/windows/win32/direct2d/supported-pixel-formats-and-alpha-modes
  66. https://learn.microsoft.com/en-us/windows/win32/direct2d/d2d-samples
  67. https://blogs.windows.com/windowsdeveloper/2013/11/19/whats-new-for-xaml-and-directx-interop-in-windows-8-1/
  68. https://walbourn.github.io/directx-sdks-of-a-certain-age/
  69. https://learn.microsoft.com/en-us/windows/win32/direct2d/svg-support
  70. https://learn.microsoft.com/en-us/windows/win32/direct2d/color-management
  71. https://learn.microsoft.com/en-us/windows/win32/wcs/advanced-color-icc-profiles
  72. https://learn.microsoft.com/en-us/windows/win32/direct3ddxgi/variable-refresh-rate-displays
  73. https://www.nuget.org/packages/Microsoft.Graphics.Win2D/1.3.0
  74. https://learn.microsoft.com/en-us/windows/apps/develop/win2d/
  75. https://learn.microsoft.com/en-us/archive/msdn-magazine/2013/march/windows-with-c-rendering-in-a-desktop-application-with-direct2d
  76. https://learn.microsoft.com/en-us/windows/win32/direct2d/devices-and-device-contexts
  77. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2ddebuglayer-overview
  78. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2ddebuglayer-portal
  79. https://learn.microsoft.com/en-us/windows/uwp/gaming/directx-and-xaml-interop
  80. https://katyscode.wordpress.com/2013/01/23/migrating-existing-direct2d-applications-to-use-direct2d-1-1-functionality-in-windows-7/
  81. https://learn.microsoft.com/en-us/windows/win32/sbscs/about-side-by-side-assemblies-
  82. https://learn.microsoft.com/en-us/windows/win32/secauthz/appcontainer-isolation
  83. https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-error-handling-policies
  84. https://learn.microsoft.com/en-us/gaming/gdk/docs/tools/tools-pc/visualstudio/gr-vs-templates
  85. https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/may/introducing-direct2d
  86. https://juce.com/blog/juce-8-feature-overview-direct-2d/
  87. https://learn.microsoft.com/en-us/windows/win32/direct2d/profiling-directx-applications
  88. https://learn.microsoft.com/en-us/windows/win32/direct3ddxgi/for-best-performance--use-dxgi-flip-model
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.