Direct2D入门

一. 资源管理(Resource management)

和Direct3D一样，Direct2D程序需要处理设备丢失(Device lost)问题。Direct2D中的资源分为设备独立资源(Device independent resource)和设备依赖资源(Device dependent resource)。

设备独立资源包括：

• ID2D1DrawingStateBlock
• ID2D1Factory
• ID2D1Geometry 和由此继承而来的接口
• ID2D1GeometrySink and ID2D1SimplifiedGeometrySink
• ID2D1StrokeStyle

设备依赖资源包括：

• ID2D1Brush 和由此继承而来的接口
• ID2D1Layer
• ID2D1RenderTarget 和由此继承而来的接口
• 其他资源

具体参见：http://msdn.microsoft.com/en-us/library/dd756757(v=VS.85).aspx

二. Direct2D程序的结构

1. 在程序初始化函数处创建设备独立资源，如ID2D1Factory，IDWriteFactory等；
2. 创建设备依赖资源，如果运行过程中出现设备丢失，需要重新创建；
3. 响应WM_PAINT消息，在OnPaint()或OnDraw()等处，用创建的资源Render；
4. 响应WM_SIZE消息，在OnSize()处调用ID2D1RenderTarget::Resize();
5. 响应WM_ERASEBKGND，在OnEraseBkgnd()处返回FALSE，阻止GDI重绘客户区背景色，设置背景色的工作交给Direct2D在Render时设置，否则在Resize时会出现窗口闪烁的问题；
6. 退出程序前，清理资源。

为提高程序的性能，尽量减少资源的创建和销毁操作，将能够重复利用的资源接口变量申明为View类的成员变量。

三. Direct2D demo

一个简单的MFC程序，用于演示Direct2D程序的结构和一些简单绘图操作。

1.Direct2D prerequisite

D2dPrerequisite.h，包含一些编译Direct2D程序所需要用到的头文件，lib库文件，帮助宏和预处理指令：

  1: //D2dPrerequisite.h
  2: #pragma once
  3: 
  4: //////////////////////////////////////////////////////////////////////////
  5: //Header files and lib files for Direct2D and DirectWrite
  6: #include <d2d1.h>		//Direct2D,for normal rendering task
  7: #include <d2d1helper.h>	
  8: #include <dwrite.h>		//DirectWrite,for drawing text
  9: #include <wincodec.h>		//Windows imaging component,for image decoding
 10: 
 11: #pragma comment(lib,"d2d1.lib")
 12: #pragma comment(lib,"dwrite.lib")
 13: #pragma comment(lib,"windowscodecs.lib")
 14: 
 15: //////////////////////////////////////////////////////////////////////////
 16: //Helper template for resource releasing
 17: template<class Interface>
 18: inline void SafeRelease(Interface **ppInterfaceToRelease)
 19: {
 20: 	if (*ppInterfaceToRelease != NULL)
 21: 	{
 22: 		(*ppInterfaceToRelease)->Release();
 23: 		(*ppInterfaceToRelease) = NULL;
 24: 	}
 25: }
 26: 
 27: #ifndef Assert
 28: #if defined( DEBUG ) || defined( _DEBUG )
 29: #define Assert(b) do {if (!(b)) {OutputDebugStringA("Assert: " #b "\n");}} while(0)
 30: #else
 31: #define Assert(b)
 32: #endif //DEBUG || _DEBUG
 33: #endif
 34: 
 35: #ifndef HINST_THISCOMPONENT
 36: EXTERN_C IMAGE_DOS_HEADER __ImageBase;
 37: #define HINST_THISCOMPONENT ((HINSTANCE)&__ImageBase)
 38: #endif

2.View类中的成员变量：

  1: //View.h
  2: private:
  3: 	//Direct2D interface
  4: 	ID2D1Factory* m_pD2d1Factory;
  5: 	ID2D1HwndRenderTarget* m_pHwndRenderTarget;
  6: 	ID2D1SolidColorBrush* m_pSolidColorBrush;
  7: 	ID2D1LinearGradientBrush* m_pLinearGradientBrush;
  8: 	ID2D1RadialGradientBrush* m_pRadialGradientBrush;
  9: 
 10: 	//DirectWrite interface
 11: 	IDWriteFactory* m_pDWriteFactory;
 12: 	IDWriteTextFormat* m_pTextFormat;

3.创建设备独立资源

  1: //View.cpp
  2: BOOL CBasicView::CreateDeviceIndependentResource()
  3: {
  4: 	HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,&m_pD2d1Factory);
  5: 	ASSERT(hr == S_OK);
  6: 
  7: 	if (SUCCEEDED(hr))
  8: 	{
  9: 		hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
 10: 			__uuidof(m_pDWriteFactory),
 11: 			reinterpret_cast<IUnknown**>(&m_pDWriteFactory));
 12: 		ASSERT(hr == S_OK);
 13: 	}
 14: 	
 15: 	//Create TextFormat object with IDWriteFactory
 16: 	if (SUCCEEDED(hr))
 17: 	{
 18: 		const CString fontName = _T("Verdana");
 19: 		const FLOAT fontSize = 32.0f;
 20: 		hr = m_pDWriteFactory->CreateTextFormat(
 21: 			fontName,
 22: 			NULL,
 23: 			DWRITE_FONT_WEIGHT_NORMAL,
 24: 			DWRITE_FONT_STYLE_NORMAL,
 25: 			DWRITE_FONT_STRETCH_NORMAL,
 26: 			fontSize,
 27: 			L"",	//locale
 28: 			&m_pTextFormat
 29: 			);
 30: 		ASSERT(hr == S_OK);
 31: 		if (SUCCEEDED(hr))
 32: 		{
 33: 			//Center alignment vertically and horizontally
 34: 			m_pTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
 35: 			m_pTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
 36: 		}
 37: 	}
 38: 	return (hr == S_OK);
 39: }

4.创建设备依赖资源

  1: //View.cpp
  2: BOOL CBasicView::CreateDeviceDependentResource()
  3: {
  4: 	ASSERT(m_pD2d1Factory != NULL);
  5: 	if (m_pHwndRenderTarget != NULL)	//There is no need to create render target
  6: 		return TRUE;
  7: 
  8: 	RECT rc;
  9: 	GetClientRect(&rc);
 10: 	D2D1_SIZE_U size = SizeU(rc.right-rc.left,rc.bottom-rc.top);
 11: 	HRESULT hr = m_pD2d1Factory->CreateHwndRenderTarget(
 12: 		RenderTargetProperties(),
 13: 		HwndRenderTargetProperties(m_hWnd,size),//Bind the HwndRenderTarget to view window
 14: 		&m_pHwndRenderTarget);
 15: 	ASSERT(hr == S_OK);
 16: 	if (SUCCEEDED(hr))
 17: 	{
 18: 		//Create solid color brush
 19: 		hr = m_pHwndRenderTarget->CreateSolidColorBrush(
 20: 			ColorF(ColorF::LightGreen),
 21: 			&m_pSolidColorBrush);
 22: 		ASSERT(hr == S_OK);
 23: 
 24: 		//Create gradient stops collection,
 25: 		//used by linear gradient brush or radial gradient brush
 26: 		ID2D1GradientStopCollection* pGradientStops = NULL;
 27: 		D2D1_GRADIENT_STOP stops[2];
 28: 		stops[0].color = ColorF(ColorF::Yellow);
 29: 		stops[0].position = 0.0f;
 30: 		stops[1].color = ColorF(ColorF::Red);
 31: 		stops[1].position = 1.0f;
 32: 		HRESULT hr = m_pHwndRenderTarget->CreateGradientStopCollection(
 33: 			stops,
 34: 			2,
 35: 			D2D1_GAMMA_2_2,
 36: 			D2D1_EXTEND_MODE_CLAMP,
 37: 			&pGradientStops);
 38: 		ASSERT(hr == S_OK);
 39: 
 40: 		//Create linear gradient brush
 41: 		hr = m_pHwndRenderTarget->CreateLinearGradientBrush(
 42: 			LinearGradientBrushProperties(Point2F(210,110),Point2F(290,190)),
 43: 			pGradientStops,
 44: 			&m_pLinearGradientBrush);
 45: 		ASSERT(hr == S_OK);
 46: 
 47: 		//Create radial gradient brush
 48: 		hr = m_pHwndRenderTarget->CreateRadialGradientBrush(
 49: 			RadialGradientBrushProperties(Point2F(350,150),Point2F(0,0),50,50),
 50: 			pGradientStops,
 51: 			&m_pRadialGradientBrush);
 52: 		ASSERT(hr == S_OK);
 53: 
 54: 		SafeRelease(&pGradientStops);
 55: 	}
 56: 	
 57: 	return (hr == S_OK);
 58: }

5.Render

  1: //View.cpp
  2: void CBasicView::Render()
  3: {
  4: 	ASSERT(m_pD2d1Factory != NULL);
  5: 	if (!m_pHwndRenderTarget)	//Render target need to be recreated
  6: 	{
  7: 		//Recreate device dependent resource
  8: 		BOOL succeeded = CreateDeviceDependentResource();
  9: 		if (!succeeded)
 10: 			return;
 11: 	}
 12: 	
 13: 	const D2D1_COLOR_F redColor = ColorF(ColorF::Red);
 14: 	const D2D1_COLOR_F greenColor = ColorF(ColorF::Green);
 15: 	const D2D1_COLOR_F blueColor = ColorF(ColorF::Blue);
 16: 	const D2D1_COLOR_F yellowColor = ColorF(ColorF::Yellow);
 17: 	const D2D1_COLOR_F pinkColor = ColorF(ColorF::Pink);
 18: 	const D2D1_COLOR_F lightBlue = ColorF(ColorF::LightBlue);
 19: 	const D2D1_COLOR_F lightGreen = ColorF(ColorF::LightGreen);
 20: 
 21: 	m_pHwndRenderTarget->BeginDraw();
 22: 	m_pHwndRenderTarget->Clear(ColorF(ColorF::White));	//Clear the background
 23: 	
 24: 	//Draw line
 25: 	//We can set the color and opacity of solid color brush at any time,
 26: 	//so there is no need to create brushes for different colors
 27: 	m_pSolidColorBrush->SetColor(redColor);	
 28: 	D2D1_POINT_2F startPoint = Point2F(10,10);
 29: 	D2D1_POINT_2F endPoint = Point2F(90,90);
 30: 	m_pHwndRenderTarget->DrawLine(startPoint,endPoint,m_pSolidColorBrush,5.0);
 31: 
 32: 	//Draw rectangle
 33: 	m_pSolidColorBrush->SetColor(greenColor);
 34: 	D2D1_RECT_F rect = RectF(110,10,190,90);
 35: 	m_pHwndRenderTarget->DrawRectangle(rect,m_pSolidColorBrush,4.0f);
 36: 
 37: 	//Draw rounded rectangle
 38: 	m_pSolidColorBrush->SetColor(blueColor);
 39: 	rect = RectF(210,10,290,90);
 40: 	D2D1_ROUNDED_RECT roundedRect = RoundedRect(rect,10,10);
 41: 	m_pHwndRenderTarget->DrawRoundedRectangle(roundedRect,m_pSolidColorBrush,3.0f);
 42: 
 43: 	//Draw ellipse
 44: 	m_pSolidColorBrush->SetColor(redColor);
 45: 	D2D1_POINT_2F center = D2D1::Point2F(350,50);
 46: 	D2D1_ELLIPSE ellipse = D2D1::Ellipse(center,40,30);
 47: 	m_pHwndRenderTarget->DrawEllipse(ellipse,m_pSolidColorBrush,3.0f);
 48: 
 49: 	//Fill rectangle
 50: 	m_pSolidColorBrush->SetColor(pinkColor);
 51: 	rect = RectF(10,110,90,190);
 52: 	m_pHwndRenderTarget->FillRectangle(rect,m_pSolidColorBrush);
 53: 
 54: 	//Fill rounded rectangle
 55: 	m_pSolidColorBrush->SetColor(blueColor);
 56: 	m_pSolidColorBrush->SetOpacity(0.3f);
 57: 	rect = RectF(110,110,190,190);
 58: 	roundedRect = RoundedRect(rect,20,20);
 59: 	m_pHwndRenderTarget->FillRoundedRectangle(roundedRect,m_pSolidColorBrush);
 60: 
 61: 	//Fill rectangle with linear gradient brush
 62: 	rect = RectF(210,110,290,190);
 63: 	m_pHwndRenderTarget->FillRectangle(rect,m_pLinearGradientBrush);
 64: 	
 65: 	//Fill ellipse with gradient brush
 66: 	ellipse = D2D1::Ellipse(Point2F(350,150),40,40);
 67: 	m_pHwndRenderTarget->FillEllipse(ellipse,m_pRadialGradientBrush);
 68: 
 69: 	//Draw text with a linear gradient brush
 70: 	const CString text = _T("Text drawed with Direct2D & DWrite!");
 71: 	rect = RectF(20,210,380,290);
 72: 	m_pHwndRenderTarget->DrawTextW(
 73: 		text,
 74: 		text.GetLength(),
 75: 		m_pTextFormat,
 76: 		rect,
 77: 		m_pLinearGradientBrush);
 78: 
 79: 	HRESULT hr = m_pHwndRenderTarget->EndDraw();
 80: 
 81: 	if (hr == D2DERR_RECREATE_TARGET)	//Render target need to be recreated
 82: 	{
 83: 		//Discard all device dependent resources,
 84: 		//and recreate them in the next render procedure
 85: 		DiscardDeviceDependentResource();
 86: 	}
 87: }

6. 销毁设备依赖资源，以备下次Render时再次创建

  1: //View.cpp
  2: void CBasicView::DiscardDeviceDependentResource()
  3: {
  4: 	SafeRelease(&m_pRadialGradientBrush);
  5: 	SafeRelease(&m_pLinearGradientBrush);
  6: 	SafeRelease(&m_pSolidColorBrush);
  7: 	SafeRelease(&m_pHwndRenderTarget);
  8: }

7.Resize

  1: //View.cpp
  2: void CBasicView::Resize(int width,int height)
  3: {
  4: 	if (m_pHwndRenderTarget)
  5: 	{
  6: 		m_pHwndRenderTarget->Resize(SizeU(width,height));
  7: 	}
  8: }

四. 程序运行结果