There are two ways to combine Direct2D with Windows GDI API in the same application:

1. Drawing Direct2D content to a GDI device context
2. Drawing GDI content to a Direct2D GDI-compatible render target

Let’s see each one!

Drawing Direct2D content to a GDI device context

For this purpose, use ID2D1DCRenderTarget instead of ID2D1HwndRenderTarget interface. If using MFC shipped with Visual Studio 2015 or newer, then CDCRenderTarget wrapper class makes the programmer life easier. Here are the steps:

1. In the WM_CREATE message handler call CWnd::EnableD2DSupport passing TRUE as second parameter. This way, the MFC framework creates a CDCRenderTarget instead of a CHwndRenderTarget object.
   
   C++

   int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct) { if (__super::OnCreate(lpCreateStruct) == -1) return -1; // Note: need Visual Studio 2015 or newer (_MFC_VER >= 0x0E00) BOOL bUseDCRenderTarget = TRUE; EnableD2DSupport(TRUE, bUseDCRenderTarget); if (!IsD2DSupportEnabled()) return -1; return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   int CChildView::OnCreate(LPCREATESTRUCT lpCreateStruct) {     if (__super::OnCreate(lpCreateStruct) == -1)         return -1;       // Note: need Visual Studio 2015 or newer (_MFC_VER >= 0x0E00)     BOOL bUseDCRenderTarget = TRUE;     EnableD2DSupport(TRUE, bUseDCRenderTarget);       if (!IsD2DSupportEnabled())         return -1;       return 0; }

2. Map AFX_WM_DRAW2D registered messge.
   
   C++

   class CChildView : public CWnd { // ... afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam); };

   1 2 3 4 5

   class CChildView : public CWnd {     // ...     afx_msg LRESULT OnAfxDraw2D(WPARAM wParam, LPARAM lParam); };

   
   
   C++

   BEGIN_MESSAGE_MAP(CChildView, CWnd) // ... ON_REGISTERED_MESSAGE(AFX_WM_DRAW2D, &CChildView::OnAfxDraw2D) END_MESSAGE_MAP()

   1 2 3 4

   BEGIN_MESSAGE_MAP(CChildView, CWnd)     // ...     ON_REGISTERED_MESSAGE(AFX_WM_DRAW2D, &CChildView::OnAfxDraw2D) END_MESSAGE_MAP()

3. Finally, get the CDCRenderTarget* passed by MFC framework in LPARAM and enjoy.
   
   C++

   LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam) { CDCRenderTarget* pDCRenderTarget = (CDCRenderTarget*)lParam; ASSERT_KINDOF(CDCRenderTarget, pDCRenderTarget); // Draw Direct2D content in GDI device context _DrawDirect2DContent(pDCRenderTarget); pDCRenderTarget->EndDraw(); // Draw using GDI CWindowDC dc(this); _DrawGDIContent(&dc); return TRUE; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   LRESULT CChildView::OnAfxDraw2D(WPARAM wParam, LPARAM lParam) {     CDCRenderTarget* pDCRenderTarget = (CDCRenderTarget*)lParam;     ASSERT_KINDOF(CDCRenderTarget, pDCRenderTarget);       // Draw Direct2D content in GDI device context     _DrawDirect2DContent(pDCRenderTarget);       pDCRenderTarget->EndDraw();       // Draw using GDI     CWindowDC dc(this);     _DrawGDIContent(&dc);       return TRUE; }

Drawing GDI content to a Direct2D GDI-compatible render target

So far, MFC has not a wrapper class for ID2D1GdiInteropRenderTarget interface. Also, CWnd::EnableD2DSupport creates a CHwndRenderTarget which is not GDI-compatible. So, we must do it ourselves. Here is the sample code:

Demo projects

Download: Direct2D and GDI Interop Demo.zip (1326)

The Visual C++ solution attached here has two simple projects showing the both Direct2D and GDI interoperatibily methods listed above.

Direct2D and GDI Interop – Demo Application

Notes

• can be observed that Direct2D drawing quality is higher than GDI drawing, because Direct2D is capable of rendering with antialiasing;
• given the first note, my opinion is that GDI drawing has no much sense once using Direct2D but never know…

Resources and related articles

• MSDN: Direct2D and GDI Interoperability Overview
• MSDN: CDCRenderTarget Class
• MSDN: ID2D1GdiInteropRenderTarget interface

Direct2D has built-in support for image processing like changing brightness or contrast, blurring, creating drop shadows, and so on. Basically, we can use for this purpose the CreateEffect and DrawImage methods of ID2D1DeviceContext interface. So far, there is no MFC wrapper class for ID2D1DeviceContext but that’s not so big issue. Once having a valid ID2D1RenderTarget instance (wrapped in CRenderTarget class) we can easily get the ID2D1DeviceContext interface by calling QueryInterface. No sweat!

Getting ID2D1DeviceContext interface in an MFC application

Or, a little bit easier, use CComQIPtr which calls QueryInterface for you.

Drawing an image using the Gaussian Blur built-in effect

Here is an example:

Just note that you should additionally include d2d1_1.h header and link your project to dxguid.lib. More details can be found in the attached demo project.

The demo project

Download: Gaussian Blur Effect demo.zip (1313)

Notes

• Picture used in the demo application is taken from http://www.icondrawer.com/gift-icons.php
• I have to apologize for blurring the little cute dog. 🙂

Resources and related articles

• MSDN: Effects
• MSDN: Built-in Effects
• MSDN: ID2D1DeviceContext interface
• MSDN: ID2D1Effect interface

As shown in previous articles, we can enable MFC Direct2D support for a window by a call of CWnd::EnableD2DSupport.
Example:

So far so good as long as all windows which use Direct2D are running in the same thread (usually the application main thread). But let’s say we have more than one window with intensive rendering (e.g. some images slide show). In this case we would like to create each window in a separate thread. But this could cause the drawing to freeze or even application to crash. So, what should we do?

Create multi-threaded Direct2D factory

If step into MFC code starting with CWnd::EnableD2DSupport, we can notice the following:

1. check if Direct2D and DirectWrite (kept in a global object of type _AFX_D2D_STATE) are already created;
2. if not, call _AFX_D2D_STATE::InitD2D with default parameters D2D1_FACTORY_TYPE_SINGLE_THREADED and DWRITE_FACTORY_TYPE_SHARED.

Now, lets see the comments from D2D1_FACTORY_TYPE enumeration.

Also, let’s see what MSDN documentation states:

• D2D1_FACTORY_TYPE_SINGLE_THREADED
  No synchronization is provided for accessing or writing to the factory or the objects it creates. If the factory or the objects are called from multiple threads, it is up to the application to provide access locking.

• D2D1_FACTORY_TYPE_MULTI_THREADED
  Direct2D provides synchronization for accessing and writing to the factory and the objects it creates, enabling safe access from multiple threads.

Making the synchronization is not so handy so we have to find a way to create a Direct2D factory that uses multi-threaded model. Fortunately, that’s very easy by a single call of CWinApp::EnableD2DSupport.

That’s all. Hurray!

Demo application

Download: MFC Direct2D Multithreading Demo.zip (1179)

The demo application can create multiple windows that perform image slideshow with Direct2D, each one in its own thread. Just push the button then select a folder containing image files.

MFC Direct2D Multithreading – Demo

Resources and related articles

• MSDN: CWinApp::EnableD2DSupport
• MSDN: D2D1CreateFactory function
• MSDN: D2D1_FACTORY_TYPE enumeration
• Codexpert blog: MFC Support for Direct2D articles