One of the most significant innovations we have brought to Visual Studio 11 is a series of tools for assisting you in developing Direct3D games. We made a quick video of some of these features on Channel9 (link). In this post, I will walk through our debugging & diagnostics support for D3D.

The new Graphics Debugger in Visual Studio is a debugging and analysis tool that captures detailed information from a Direct3D application as it executes. You can use it to:

• Capture rendered frames for later inspection and analysis.
• View DirectX events and their effects on the application.
• View 3D meshes before and after vertex shader transformations.
• Discover which DirectX events contribute to the color of a specific pixel.
• Jump directly to the location in source code for a particular DirectX call

Alternatively you can click on Copy Info button and paste entire information about Installed Product to a text editor and do search for the corresponding KB

I’m primary using IBM Clearcase as versioninig system and I have n number of issues ever since I started using with Windows 7. The same issue happened though I copied my source to local folder and debugging from there.

Simply took the dump and attached to WinDBG. !analyze -v had given me following call stack

EXCEPTION_RECORD:  002ad92c -- (.exr 0x2ad92c)
ExceptionAddress: 3fe083d0
   ExceptionCode: c0000005 (Access violation)
  ExceptionFlags: 00000000
NumberParameters: 2
   Parameter[0]: 00000008
   Parameter[1]: 3fe083d0
Attempt to execute non-executable address 3fe083d0

FAULTING_THREAD:  00002718

DEFAULT_BUCKET_ID:  SILENT

PROCESS_NAME:  devenv.exe

ERROR_CODE: (NTSTATUS) 0x80000003 - {EXCEPTION}  Breakpoint  A breakpoint has been reached.

EXCEPTION_CODE: (HRESULT) 0x80000003 (2147483651) - One or more arguments are invalid

NTGLOBALFLAG:  400

APPLICATION_VERIFIER_FLAGS:  0

MANAGED_STACK: !dumpstack -EE
OS Thread Id: 0x2718 (0)
Current frame:
ChildEBP RetAddr  Caller,Callee
002af168 71bc5a99 (MethodDesc 0x714cc250 +0x79 System.Collections.Generic.Dictionary`2+ValueCollection+Enumerator[[System.Int32, mscorlib],[System.__Canon, mscorlib]].MoveNext())

CONTEXT:  002ad948 -- (.cxr 0x2ad948)
eax=59730146 ebx=00000000 ecx=01a72c50 edx=0000001d esi=01a72c50 edi=01a729c8
eip=3fe083d0 esp=002adc2c ebp=002adeb0 iopl=0         nv up ei ng nz na pe nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00010286
3fe083d0 ??              ???
Resetting default scope

WRITE_ADDRESS:  3fe083d0 

FOLLOWUP_IP:
msenv!CDockManager::PruneAllDeadPanes+45
5986cbf6 e97745f8ff      jmp     msenv!CDockManager::PruneAllDeadPanes+0x45 (597f1172)

FAILED_INSTRUCTION_ADDRESS:
+5789952f04fedcac
3fe083d0 ??              ???

PRIMARY_PROBLEM_CLASS:  SILENT

BUGCHECK_STR:  APPLICATION_FAULT_SILENT

LAST_CONTROL_TRANSFER:  from 5986cbf6 to 3fe083d0

IP_ON_HEAP:  3fe083d0
The fault address in not in any loaded module, please check your build's rebase
log at \bin\build_logs\timebuild\ntrebase.log for module which may
contain the address if it were loaded.

IP_IN_FREE_BLOCK: 3fe083d0

STACK_TEXT:
3fe083d0 unknown+0x0
5986cbf6 msenv!CDockManager::PruneAllDeadPanes+0x45
597eef9b msenv!CDockManager::SaveUI+0xb7
598122a5 msenv!CPane::TransitionToDesign+0x46
597f67a9 msenv!CVsShellDebugMgr::m_OnModeChange+0xe6
5976aca3 msenv!CVsUIShell::OnModeChange+0x21
5f4dbfa3 vsdebug!CDebugger::SetShellMode+0x9b
5f4dc04f vsdebug!CDebugger::OnModeChange+0x44
5f4dbeef vsdebug!CDebugger::SetDebugMode+0x69
5f4f2c93 vsdebug!CDebugger::OnExitBreakState+0xaa
5f53cab1 vsdebug!CDebugger::OnDebuggingStopped+0x6e
5f51bcb6 vsdebug!CDebugger::HandleEvent+0x8ae
5f4dbc19 vsdebug!CDebugger::Event+0xef
5f4dbaef vsdebug!sdm::CDebugManager::HandleEvent+0xb5
75eefc8f rpcrt4!Invoke+0x2a
75f54c53 rpcrt4!NdrStubCall2+0x2d6
75e9d936 ole32!CStdStubBuffer_Invoke+0xb6
75e9d9c6 ole32!SyncStubInvoke+0x3c
75e9df1f ole32!StubInvoke+0xb9
75db223c ole32!CCtxComChnl::ContextInvoke+0xfa
75db2131 ole32!MTAInvoke+0x1a
75db30fa ole32!STAInvoke+0x46
75e9de47 ole32!AppInvoke+0xab
75e9dcbb ole32!ComInvokeWithLockAndIPID+0x372
75e9e34c ole32!ComInvoke+0xc5
75db2ed2 ole32!ThreadDispatch+0x23
75db2e91 ole32!ThreadWndProc+0x161
762986ef user32!InternalCallWinProc+0x23
76298876 user32!UserCallWinProcCheckWow+0x14b
762989b5 user32!DispatchMessageWorker+0x35e
76298e9c user32!DispatchMessageW+0xf
75d7d6be ole32!CCliModalLoop::PeekRPCAndDDEMessage+0x4c
75d7d66d ole32!CCliModalLoop::FindMessage+0x30
75d7d57e ole32!CCliModalLoop::HandleWakeForMsg+0x41
75d7d633 ole32!CCliModalLoop::BlockFn+0xc3
75d71117 ole32!CoWaitForMultipleHandles+0xcd
5f513ed6 vsdebug!sdm::CDebugManager::WaitForEvent+0x8a
5f526aa0 vsdebug!CDebugger::WaitForDebuggingToStop+0x51
5f526fed vsdebug!CDebugger::TerminateSession+0x106
5f52711a vsdebug!CDebugger::StopDebugging+0x10a
5f4e8014 vsdebug!CVSDebugPackage::Exec+0x5f9
5974249f msenv!CVSCommandTarget::ExecCmd+0x937
59884617 msenv!FTranslateAcceleratorEx+0x4a3
597581c3 msenv!FTranslateAccelerator+0x49
59758045 msenv!MainFTranslateMessage+0x1a7
59757f2b msenv!CMsoComponent::FPreTranslateMessage+0x72
59757ec0 msenv!SCM_MsoStdCompMgr::FPreTranslateMessage+0xdd
5974152c msenv!EnvironmentMsgLoop+0x159
597fb9bd msenv!CMsoCMHandler::FPushMessageLoop+0x86
597fb94d msenv!SCM::FPushMessageLoop+0xb7
597fb8e9 msenv!SCM_MsoCompMgr::FPushMessageLoop+0x28
597fb8b8 msenv!CMsoComponent::PushMsgLoop+0x28
597fbe4e msenv!VStudioMainLogged+0x482
597f7561 msenv!VStudioMain+0xc1
2f6aaabc devenv!util_CallVsMain+0xff
2f6a78f2 devenv!CDevEnvAppId::Run+0x11fd
2f6a7bf4 devenv!WinMain+0x74
2f6a7c68 devenv!License::GetPID+0x258
765a1114 kernel32!BaseThreadInitThunk+0xe
7791b429 ntdll!__RtlUserThreadStart+0x70
7791b3fc ntdll!_RtlUserThreadStart+0x1b

SYMBOL_STACK_INDEX:  1

SYMBOL_NAME:  msenv!CDockManager::PruneAllDeadPanes+45

FOLLOWUP_NAME:  MachineOwner

MODULE_NAME: msenv

IMAGE_NAME:  msenv.dll

DEBUG_FLR_IMAGE_TIMESTAMP:  488f2b9f

STACK_COMMAND:  .cxr 002AD948 ; kb ; dds 2adc2c ; kb

FAILURE_BUCKET_ID:  SILENT_80000003_msenv.dll!CDockManager::PruneAllDeadPanes

BUCKET_ID:  APPLICATION_FAULT_SILENT_BAD_IP_msenv!CDockManager::PruneAllDeadPanes+45

WATSON_STAGEONE_URL:  http://watson.microsoft.com/StageOne/devenv_exe/9_0_30729_1/488f2b50/unknown/0_0_0_0/bbbbbbb4/80000003/00000000.htm?Retriage=1

Followup: MachineOwner
---------

Luckily a Google search with the call stack has returneda single relevant result about this issue in Microsoft Connect.

Visual Studio 2008 IDE Crashes Returning to Design Mode When Stopping Debugging Native C++ Code

Microsoft has released a patch to resolve this issue. Download

You might have seen the above warning when you open a Visual Studio solution on a mapped network drive. This especially appears when you work with clearcase mapped network drives.

Find for caspol.exe in your Windows\Microsoft.NET\Framework folder.

C:\Windows\Microsoft.NET\Framework\v2.0.50727\CasPol.exe -m -pp off -cg 1.2 FullTrust

This will grant full trust to local intranet code group. Note that caspol tool will apply the security settings for 3.0, 3.5 as well though it’s coming with .NET 2.0

void SaveBitmapToFile( BYTE* pBitmapBits, LONG lWidth, LONG lHeight,WORD wBitsPerPixel, LPCTSTR lpszFileName )
{
    BITMAPINFOHEADER bmpInfoHeader = {0};
    // Set the size
    bmpInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
    // Bit count
    bmpInfoHeader.biBitCount = wBitsPerPixel;
    // Use all colors
    bmpInfoHeader.biClrImportant = 0;
    // Use as many colors according to bits per pixel
    bmpInfoHeader.biClrUsed = 0;
    // Store as un Compressed
    bmpInfoHeader.biCompression = BI_RGB;
    // Set the height in pixels
    bmpInfoHeader.biHeight = lHeight;
    // Width of the Image in pixels
    bmpInfoHeader.biWidth = lWidth;
    // Default number of planes
    bmpInfoHeader.biPlanes = 1;
    // Calculate the image size in bytes
    bmpInfoHeader.biSizeImage = lWidth* lHeight * (wBitsPerPixel/8);

    BITMAPFILEHEADER bfh = {0};
    // This value should be values of BM letters i.e 0x4D42
    // 0x4D = M 0×42 = B storing in reverse order to match with endian
    bfh.bfType=0x4D42;
    /* or
    bfh.bfType = ‘B’+(‘M’ << 8);
    // <<8 used to shift ‘M’ to end
    */
    // Offset to the RGBQUAD
    bfh.bfOffBits = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
    // Total size of image including size of headers
    bfh.bfSize = bfh.bfOffBits + bmpInfoHeader.biSizeImage;
    // Create the file in disk to write
    HANDLE hFile = CreateFile( lpszFileName,GENERIC_WRITE, 0,NULL,

                               CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,NULL);

    if( !hFile ) // return if error opening file
    {
        return;
    }

    DWORD dwWritten = 0;
    // Write the File header
    WriteFile( hFile, &bfh, sizeof(bfh), &dwWritten , NULL );
    // Write the bitmap info header
    WriteFile( hFile, &bmpInfoHeader, sizeof(bmpInfoHeader), &dwWritten, NULL );
    // Write the RGB Data
    WriteFile( hFile, pBitmapBits, bmpInfoHeader.biSizeImage, &dwWritten, NULL );
    // Close the file handle
    CloseHandle( hFile );
}

void CLoadIconSampleDlg::OnBnClickedButtonSaveIcon()
{
	// Loading resource from DLL.
	HMODULE h = LoadLibrary( L"myresource.dll" );

	if( !h )
	{
		MessageBox( L"Failed to load library" );
		return;
	}

	INT id = GetDlgItemInt( IDC_EDIT1 );
	m_hLoadedIcon = LoadIcon( (HINSTANCE) h , MAKEINTRESOURCE( id ) );

	CBitmap bmpSave;
	CClientDC dc(this);
	bmpSave.CreateCompatibleBitmap( &dc, 32, 32 );

	CDC dcMem;
	dcMem.CreateCompatibleDC( &dc );
	dcMem.SelectObject( &bmpSave );
	dcMem.DrawIcon( 0, 0, m_hLoadedIcon );

	BITMAP bmpInfo;
	bmpSave.GetBitmap( &bmpInfo );

	int size = bmpInfo.bmHeight* bmpInfo.bmWidth * (bmpInfo.bmBitsPixel / 8 );
	unsigned char* pBytes = new unsigned char[size];
	bmpSave.GetBitmapBits( size, pBytes );
	SaveBitmapToFile( pBytes, 32, 32, bmpInfo.bmBitsPixel, _T( "C:\\temp\\temp.bmp" ));
	delete []pBytes;

	FreeLibrary( h );
}

const to data

This is the simplest form of pointer definition that we always do.

const int* data3 = arr2; // Const to data
data3[0] = 55;  // ERROR: Data can't be changed
data3 = arr1;    // Success:  Can't change the pointer to somewhere else

Here the data is can’t changed using data3 pointer. but the pointer itself can be modified and can point to some other location.

Usually we don’t care even if pass the pointer to some function and that pointer changes to some other location, as the function parameters points to same location but the pointer is a copy of actual parameter. But things may go different if we wrongly pass reference to function parameters even it’s const. So we’ve to take care this while designing the interfaces.

void Foo(  LPCTSTR& lpszValue )
{
	lpszValue = _T( "codereflect.com" );
}

int _tmain(int argc, _TCHAR* argv[])
{
	LPCTSTR sz = NULL;
	Foo(sz);
	_tprintf( sz );
	return 0;
}

const to pointer

In this form of usage, the pointer can’t be changed to some location but the data can be changed.

int* const data2 = arr2; // const to pointer
data2 = arr1;    // Can't change the pointer to somewhere else
data2[0] = 55;  // SUCCESS: Data can be changed

const to both data and pointer

This is the goodness of both . The most secure pointer.

const int* const data1 = arr1; // Const to both pointer and data
data1 = arr2;    // ERROR: can't change the pointer
data1[0] = 100; // ERROR: can't change the data

Roughly we’ve two methods to do this.

Method #1. Handle the NCHITTEST message and ignore while user click on the caption area (Titlebar). This method doesn’t work well in Windows 7/Vista if Aero is enabled. This method works with any type of Window having titlebar. The disadvantage of this method is , the user will still able to move using keyboard, if system menu is available.

LRESULT CMoveWindowSampleDlg::OnNcHitTest(CPoint point)
{
    UINT nHitTest = CDialogEx::OnNcHitTest(point);

    if( HTCAPTION == nHitTest )
        nHitTest = HTNOWHERE;

    return nHitTest;
}

Method #2 – Remove the Move command from System Menu (Works with windows having system menu stle (WS_SYSMENU) ). The the Move command in the system menu will be removed in this case. Windows will internally disable the movement of this kind of Windows.

BOOL CMoveWindowSampleDlg::OnInitDialog()
{
    CDialogEx::OnInitDialog();

    CMenu* pSysMenu = GetSystemMenu(FALSE);

    if (pSysMenu != NULL)
    {
        pSysMenu->RemoveMenu( SC_MOVE, MF_BYCOMMAND );
       }
...

       return TRUE;
}

PS: Using method 2, this is the same method we use to disable the close button of a Window. For disabling a menu/titlebar button. Call EnableMenu function with relevant parameters.

Visual Studio IDE is consistently getting improved over the versions but still some of the feature are missing like Symbol Search, file search within the IDE until Visual Studio 2010. It’s really important while managing large projects. The best thing in the Visual Studio 2010, is the extensibility SDK. It’s far more flexible and prominent comparing to it’s predecessors.

Microsoft has created a really helpful site to host the useful tools for Visual Studio created by developers across the world. Even Microsoft has created some really cool tools for Visual Studio which is freely available in Visual Studio Gallery.

Productivity tools are one of best extensions available. It contains a bunch of features to improve your Visual Studio 2010 experience. You can download it from Visual Studio Gallery. The features can be simply enabled and disabled through Tools->Option menu.

Let’s have a quick look into the features. Each options are described well in their home page itself. Let’s skim through the features anyway. This contains only the features I handpicked from the whole features available. You can see the entire features the home page itself. The descriptions and screenshots are given same as the extension’s homepage.

Solution Navigator  (More Info)

This is one of the best feature.

• Expand code files to navigate to its classes, expand classes to navigate to their members, and so on (C# and VB only)
• Search your solution, all the way down to class members
• Filter your solution or projects to see just opened files, unsaved files, and so on
• View related information about classes and members (such as references or callers/callees for C#)
• Preview images by hovering over them, or preview rich information by hovering over code item

Solution Navigator also provides interactive tooltips in C# and VB code (replacing the default “quick info” tooltips) that give you the same kind of data, but right at your fingertips.  In addition to getting the tooltips on hover, you can:

• Press Ctrl+1 to open a relevant tooltip at the current cursor location
• Press Ctrl+2 to quickly navigate to any class/member in the current source file

Ctrl + Click Go To Definition
This extension gives the editor a web browser by adding clickable hyperlinks to symbols in your code as you hold down the Ctrl key.

Align Assignments
This extension is useful for making your code a little more readable by aligning the assignments when you type Ctrl+Alt+] such that it takes this:

And turns it into this:

Please note: This may conflict with your formatting settings. E.g. in C# you will need to disable: Tools->Options->Text Editor->C#->Formatting->Spacing->"Ignore spaces in declaration statements"

Triple Click
It’s never been easier to select a line of code from the mouse by simple triple-clicking anywhere on the line.

Highlight Current Line
As the resolution of monitors increases, it’s becoming more difficult to find the caret in the code editor.  The highlight current line extension makes it easy to find the caret by highlighting the line that the caret is on in the editor.  You can even configure the default colour by changing the setting for “Current Line (Extension)” and “Current Line Inactive (Extension)” in Tools Options Fonts & Colors.

HTML Copy (More Info)
This extension provides support for the HTML Clipboard format when cutting or copying code from the editor.  This means that you’ll no longer have to go fix up the formatting of your code when you paste it into a TFS bug form or any other HTML based control.

Colorized Parameter Help
This extension improves consistency with the editor by applying syntax highlighting to the contents of the Parameter Help window for C# &VB.
Please note: Syntax highlighting colors can be customized using the display items prefixed with “Signature Help” in the “Fonts and Colors” menu.

Tab Well UI
This extension allows you to completely customize the behavior of your document tabs from the Productivity Power Tools Options: See More Info

Auto Brace Completion
Automatic Brace Completion improves the productivity of writing code by automatically inserting the closing code construct when the opening construct is typed for VB & C#.  More specifically, this extension:

• Supports the following constructs: (), {}, [], <>, “”, and ‘’. 
• Allows you to press <TAB> to navigate past the next enclosing brace
• Allows you to automatically complete a statement in C# by inserting the closing semi-colon and moving you to the next line with SHIFT + ENTER

But GDI was too old and was introduced with the initial versions of the Windows and over the time the capabilities of graphics hardware has grown and so does the demand for creating Visually Rich UI. With Windows 7, Microsoft has introduced a totally revamped 2D graphics subsystem called Direct2D based on their prominent Direct3D platform to create high quality 2D rendering. If you know or not, Windows Aero system is already taking advantage of graphics hardware since Windows Vista. This is supposed to replace the GDI APIs in the coming years. Direct2D is not only available under Windows 7 but Microsoft has made it available in Window Vista with the latest service pack upgrade.

The major advantages of the Direct2D APIs are it’s hardware accelerated and provides high quality 2D rendering. It enables the user to create visually rich applications by paying less effort, when comparing to conventional APIs .

GDI uses Pixel graphics but Direct2D can supports vector graphics as well, in which mathematical formulas are used to draw the lines and curves. Vector graphics provides high quality rendering independent of resolution of the device, while the pixelated graphics has dependency with resolution which may results in choppy graphics.

Most of the GDI APIs are not using anti-aliasing and transparency. Ofcrouse there are functions to do so but always there’s programming cost for taking advantage of these features. Also if we apply transparency and anti-aliasing, the computations are done using CPU. Direct2D can take advantage of graphics hardware and delegate the computationally intensive tasks to GPU.

Direct2D built on top of Direct3D components. The layered architecture is described below

You can see the underlying layers are Direct3D which make use of DXGI(DirectX Graphics Infrastructure), which manages the low level graphics related tasks that are independent of DirectX graphics runtime. DXGI provides common framework for graphics components. Simultaneously a high performance software rasterizer is available when the hardware acceleration is not possible. Another advantage of Direct2D API is, it’s using lightweight COM. It’s almost like simple C++ class. No BSTRS, COM Variants, Interfaces, Apartments etc.

Let’s start analyzing a simple Direct2D Program

There are 3 main components inevitable for enabling D2D rendering your application.

• A rendering Window and its handle (HWND)
• ID2D1Factory object to create the Direct2D resources
• ID2D1HwndRenderTarget object to draw the scene on the window.

The below example provides steps for enabling Direct2D Rendering in your MFC Application. It’s hard to describe the parameters of all APIs. Please refer them in MSDN.

Create your Window

Here I’m taking a dialog based application for rendering. The functions and messages may change if you’re using any other type of applications like SDI or MDI. No need to reinvent the wheel, allow the wizard to create your main dialog.

Prepare your Rendering Engine

Let’s delegate all the rendering tasks to another class instead of managing everything in the dialog class. I call this class as Direct2DHandler.

The Direct2DHandler declaration goes like below and it exposes the following functions.

#pragma once
#include <d2d1.h>
#include <d2d1helper.h>

class Direct2DHandler
{
public:
	Direct2DHandler( HWND hWnd ); // ctor
	~Direct2DHandler(void); // dtor
	HRESULT Initialize(); // Initialize the rendering
	HRESULT OnRender(); // Called from OnPaint function
	void OnResize(UINT width, UINT height);

private:
	HRESULT CreateDeviceResources(); // Create resources for drawing
	void DiscardDeviceResources(); // Release resources for drawing

private:

	HWND					m_hWnd;
	ID2D1Factory*			m_pDirect2dFactory;
	ID2D1HwndRenderTarget*	m_pRenderTarget;
	ID2D1SolidColorBrush*	m_pLightSlateGrayBrush;
	ID2D1LinearGradientBrush* m_pLinearGradientBrush;
};

The constructor

does nothing other than calling CoInitialize() function and initialize the member variables( mostly to NULL).

The Initialize function

creates the Direct2D factor object, which similar the HDC (context variable) in GDI.

HRESULT Direct2DHandler::Initialize()
{
    HRESULT hr = S_OK;

    // Create a Direct2D factory.
    hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDirect2dFactory);

    return hr;
}

OnResize

function handles the rendering area for the render target. We will be using whole window area in this example.

void Direct2DHandler::OnResize(UINT width, UINT height)
{
    if (m_pRenderTarget)
    {
        // Note: This method can fail, but it's okay to ignore the
        // error here, because the error will be returned again
        // the next time EndDraw is called.
        m_pRenderTarget->Resize(D2D1::SizeU(width, height));
    }
}

OnRender

function does the following

1. Create the device resource for drawing (if not created)
2. Render the scene to the Window
3. Release the resources if error occurred

If you’re experienced 3D programming probably you might be knowing about the role of matrix and how the affects the rendering object. The matrix can be used for representing the objects coordinates system. We can apply rotation, translation (movement) etc (collectively called transformation). on a matrix and this can be used for specifying how object must be rendered. Here we’re using D2D1::Matrix3x2F::Identity() helper function which creates an identity matrix(object will be rendered at origin without any transformation)

m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());

We can clear the rendering area with a default color (as the dialog background filled with some default color according to Window’s theme. Here I selected white color

m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));

The important thing is, whatever you draw for the scene must be done between BeginDraw() and EndDraw() APIs. The other part of this code is simply straight forward and you can easily grasp it. See the source below.

HRESULT Direct2DHandler::OnRender()
{
	HRESULT hr = S_OK;

	hr = CreateDeviceResources();

	if (SUCCEEDED(hr))
	{
		m_pRenderTarget->BeginDraw();
		m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());
		m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));
		D2D1_SIZE_F rtSize = m_pRenderTarget->GetSize();
		// Draw a grid background.
		int width = static_cast<int>(rtSize.width);
		int height = static_cast<int>(rtSize.height);

		// Draw two rectangles.
		D2D1_RECT_F rectangle1 = D2D1::RectF(
			rtSize.width/2 - 50.0f,
			rtSize.height/2 - 50.0f,
			rtSize.width/2 + 50.0f,
			rtSize.height/2 + 50.0f
			);

		D2D1_RECT_F rectangle2 = D2D1::RectF(
			rtSize.width/2 - 100.0f,
			rtSize.height/2 - 100.0f,
			rtSize.width/2 + 100.0f,
			rtSize.height/2 + 100.0f
			);

		// Draw the outline of a rectangle.
		m_pRenderTarget->FillRectangle(&rectangle2, m_pLinearGradientBrush);

		// Draw a filled rectangle.
		m_pRenderTarget->FillRectangle(&rectangle1, m_pLightSlateGrayBrush);

		hr = m_pRenderTarget->EndDraw();

	}
	if (hr == D2DERR_RECREATE_TARGET)
	{
		hr = S_OK;
		DiscardDeviceResources();
	}
	return hr;
}

CreateDeviceResources

is slightly a lengthy function to initialize the required resources for rendering, like we create pens, brushes, bitmaps etc. Here mainly I’m creating a light colored solid brush and linear gradient brush to render as depicted in above picture. The comments are inlined and please read it along with the code. It will be interesting to learn about gradient brushes. If you’ve created a gradient brush in photoshop things will be far more easy. We can put stop spots to controls the end of gradients also line can be used for representing flow and angle for the gradient. Simple isn’t it? Like we create a normal gradient. See the code below.

HRESULT Direct2DHandler::CreateDeviceResources()
{
    HRESULT hr = S_OK;

    if (!m_pRenderTarget)
    {
        RECT rc;
        GetClientRect(m_hWnd, &rc);

        D2D1_SIZE_U size = D2D1::SizeU(
            rc.right - rc.left,
            rc.bottom - rc.top
            );

        // Create a Direct2D render target.
        hr = m_pDirect2dFactory->CreateHwndRenderTarget(
            D2D1::RenderTargetProperties(),
            D2D1::HwndRenderTargetProperties(m_hWnd, size),
            &m_pRenderTarget
            );

        if (SUCCEEDED(hr))
        {
            // Create a gray brush.
            hr = m_pRenderTarget->CreateSolidColorBrush(
                D2D1::ColorF(D2D1::ColorF::LightSlateGray),
                &m_pLightSlateGrayBrush
                );
        }

		// Create an array of gradient stops to put in the gradient stop
		// collection that will be used in the gradient brush.
		ID2D1GradientStopCollection *pGradientStops = NULL;

		D2D1_GRADIENT_STOP gradientStops[2];
		gradientStops[0].color = D2D1::ColorF(D2D1::ColorF::Maroon, 1);
		gradientStops[0].position = 0.0f;
		gradientStops[1].color = D2D1::ColorF(D2D1::ColorF::Red, 1);
		gradientStops[1].position = 1.0f;
		// Create the ID2D1GradientStopCollection from a previously
		// declared array of D2D1_GRADIENT_STOP structs.
		hr = m_pRenderTarget->CreateGradientStopCollection(
			gradientStops,
			2,
			D2D1_GAMMA_2_2,
			D2D1_EXTEND_MODE_CLAMP,
			&pGradientStops
			);
		// The line that determines the direction of the gradient starts at
		// the upper-left corner of the square and ends at the lower-right corner.

		if (SUCCEEDED(hr))
		{
			hr = m_pRenderTarget->CreateLinearGradientBrush(
				D2D1::LinearGradientBrushProperties(
				D2D1::Point2F(0, 0),
				D2D1::Point2F(300, 300)),
				pGradientStops,
				&m_pLinearGradientBrush
				);
		}

    }

    return hr;
}

DiscardDeviceResources

Just releases the allocated resouces. It simply uses helper macro SafeRelease described below the code.

void Direct2DHandler::DiscardDeviceResources()
{
    SafeRelease(&m_pRenderTarget);
    SafeRelease(&m_pLightSlateGrayBrush);
    SafeRelease(&m_pLinearGradientBrush);
}

template<class Interface>
inline void SafeRelease(
    Interface **ppInterfaceToRelease
    )
{
    if (*ppInterfaceToRelease != NULL)
    {
        (*ppInterfaceToRelease)->Release();

        (*ppInterfaceToRelease) = NULL;
    }
}

Initializing Rendering in Dialog class

In the

OnInitDialog function,

allocate memory for the Direct2DHandler class and Initialize it. You can call this from OnCreate function as well but ensure that there’s a valid Window handle is there.

m_pRender = new Direct2DHandler( m_hWnd );
m_pRender->Initialize();

Disable Default Background Drawing

Disable the default OnErasBkgrnd function because it may cause flickering while drawing. Also we’re occupying full client area in the dialog and the background is clearing is OnRender function itself.

BOOL CDirect2DDemoDlg::OnEraseBkgnd(CDC* pDC)
{
    return FALSE;//CDialogEx::OnEraseBkgnd(pDC);
}

OnSize (WM_SIZE)

function handles the Window size events. It will resize render target according to the Window Size.

void CDirect2DDemoDlg::OnSize(UINT nType, int cx, int cy)
{
    CDialogEx::OnSize(nType, cx, cy);
    if( m_pRender )
        m_pRender->OnResize( cx, cy );
}

OnPaint function

calls OnRender function of Direct2DHandler to draw the scene.

void CDirect2DDemoDlg::OnPaint()
{
    if (IsIconic())
    {
        // code for handling when window is minimized. Check original CPP file attached.
    }
    else
    {
        // CDialogEx::OnPaint(); no need to call this.
        if( m_pRender )
            m_pRender->OnRender();
    }
}

Linking

The Application must link to d2d1.lib through project settings or using #pragma comment( lib, “d2d1.lib” ) in the source file

d2d1helper

d2d1helper.h contains some useful functions to help the drawing. See the header for more details.

OK that’s the basics of creating Direct2D rendering for your Windows Application. Go ahead with the attached source code.

The project file is in Visual Studio 2010 format, but basically you only need to have Direct2DHandler class. You can also use other prior version of Visual Studio with Windows 7/Vista SDK.

Note: Take whole responsibility of downloading and executing the code shared here. Don’t sue me. It was virus free, malware free when I uploaded.

Download Demo Source code

Here’s a free tool to play around with Visual Studio 2010. You can edit the theme for Visual Studio with Visual Studio Color Theme Editor. It comes up with some default flavors of themes but we can also customize or download pre-created themes from any website. You can see a bunch of extensions, tools, themes etc. at Visual Studio Gallery.

Also studiostyles.info contains 100’s of themes to satisfy your moods. The Visual Studio 2010 extensibility library contains lot of gems to make everything in your way. Not only themes, the whole Visual Studio and it’s contents can be taken in your hand using Visual Studio 2010 SDK. It’s much more flexible and innovative than it’s predecessors. You can get a bit more detailed scoop here. Anyways have a nice time with colors

Bonus: How many of you guys are fascinated with keyboard shortcuts? I usually use mouse only if I can’t operate something with keyobard. Have you ever wished, if we could hide the unusable menubar? Matthew Johnson has written a nice extension to hide the menubar from Visual Studio 2010 IDE. On hitting, alt key will enable the menubar again. You can directly press the Alt+ Any (valid) key (e.g. Alt+F, Alt+T etc.)