Printing and Print Preview OpenGL with MFC

Introduction

Wrapping OpenGL with MFC can take the advantages of both APIs: fast rendering and an elegant GUI. However, due to the fact that many printer drivers can't work with the SetPixelFormat() function, it is not feasible to render an OpenGL scene to a printer directly. This article presents an approach to copy an OpenGL scene to a DIB section, and then to print it out.

There are at least 3 available approaches for OpenGL printing.

1. Capture the screen. This method is easy. You can use the Windows BitBlt() function or the OpenGL glReadPixel() command to make a screen shot and print it out. Although these two functions use different approaches, you get the same result. Since the resolution of a screen is much lower than a printer's, you can't get a picture with decent quality. Furthermore, if the window's client area is clipped by another window, say, a toolbar or a modeless dialog box, the clipping window will show in the result.

2. Use an enhanced metafile device context. Currently it works only on Windows NT, therefore it is not portable to Windows 9x.

3. Use off-screen rendering. This technique can print an image with high resolution. However, if the printer's resolution is very high and the page size is very large, this approach requires large memory to hold the image during printing. A workaround is to reduce the image's resolution when large memory is required. I will use this method in this article.

OpenGL Off-Screen Rendering

First, I call Windows function CreateDIBSection() to create a DIB section, select it into a memory DC, then create an OpenGL memory RC associated with the memory DC. After rendering the scene, call StretchDIBits() to copy the image to the printer DC. In this way, I get reasonably good print quality.

To simplify the interface, the implementation is wrapped in CGLObj class, and only one interface function, OnPrint(), is needed for printing and print preview. Internally, the method wraps three virtual functions OnPrint1(), OnPrint2(), and RenderScene() to make the customization flexible.

The printing-related code segment in the header file is as follows:

class CGLObj
{
public:
	CGLObj();           

...

// Printing

	HDC         m_hOldDC;
	HDC         m_hMemDC;
	HGLRC       m_hOldRC;
	HGLRC       m_hMemRC;
	BITMAPINFO  m_bmi;
	LPVOID      m_pBitmapBits;
	HBITMAP     m_hDib;
	HGDIOBJ     m_hOldDib;
	CSize       m_szPage;	

// Operations

protected:
	virtual bool InitializeOpenGL(CView* pView);
	virtual void SetFrustum();  // For both screen and printing RCs

	virtual bool SetDCPixelFormat(HDC hDC, DWORD dwFlags);  // For both screen and printing RCs

	virtual void SetOpenGLState();  // For both screen and printing RCs

	virtual void CreateDisplayList(UINT nList);  // For both screen and printing RCs

	virtual void RenderScene();  // For both screen and printing RCs

	virtual void OnSize(int cx, int cy);
	virtual void OnPrint(CDC* pDC, CPrintInfo* pInfo, CView* pView);  // Interface function

	virtual void OnPrint1(CDC* pDC, CPrintInfo* pInfo, CView* pView);
	virtual void OnPrint2(CDC* pDC);

// Implementation

protected:
	virtual ~CGLObj();
};

Create DIB Section

The size of the DIB section depends on the size of the display device. I call GetDeviceCaps() to retrieve the size of the display device for either printing or print preview. When print previewing, I use screen resolution; when printing, I use the adjusted printer's resolution. Ideally, I hope I can use the printer's full resolution if memory and speed is not a problem. However, for a printer with 720 DPI and using letter-sized paper, the memory of a DIB section is easily in excess of 100MB. That is why I reduce the printing resolution. I then use this size to create a DIB section. After I create the memory DC, I select the handle of the DIB section to the DC.

Setup Memory RC Associate to Memory DC

Setup a memory RC is similar to setup a screen RC. The only difference is the flag, which specifies properties of the pixel buffer. I set PFD_DRAW_TO_WINDOW and PFD_DOUBLEBUFFER for the screen RC, but I need PFD_DRAW_TO_BITMAP for the memory RC. Thus, I made a helper function SetDCPixelFormat() to reuse this part of code. The OpenGL state and frustum of the memory RC are also the same as the screen RC. I therefore made SetOpenGLState() and SetFrustum() functions work for both RCs. Due to the fact that the display list is not reusable across RCs, I have to call the CreateDisplayList() function to create it again with the memory RC. If you use a texture object, you need to create it again with the new RC here.

The image drawn by bit pattern manipulation functions, such as glLineStipple(), and the bitmap font may be changed when you perform printing and print preview. You need to create them again based on the ratio of the screen and adjusted printer resolutions.

Copy DIB Section to DC

After rendering the scene to the DIB section, I copy the image in the DIB section to the destination, which is a DC for either print preview or printing. Before copying, I have to map the size of the DIB section to the size of the destination. The page can be either portrait or landscape; and the image can also be either portrait or landscape. So there are four mapping cases. The size of the printing image is stored in szImageOnPage. The StretchDIBits() function is used to copy and stretch the image in the DIB section to the DC for either print preview or printing.

Implementation

The CGLObj class is very flexible to use with View. You can use aggregation, acquaintance, multiple-inheritance, virtual-inheritance, or whatever you like. You can also uncouple the rendering implementation from printing, and make two classes. This may be more flexible.

In the example, I use virtual-inheritance. I derive CGLView from CView and CGLObj, in which CGLObj is a virtual base class. The implementation is only one line in CGLView::OnPrint():

void CGLView::OnPrint(CDC* pDC, CPrintInfo* pInfo) 
{
	CGLObj::OnPrint(pDC, pInfo, this);
}

For simplicity, I do not handle multiple views. You need to handle the RC for View activation if you need multiple views.