Printing and Print Preview OpenGL in MFC
Rating: 
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 do not work with the SetPixelFormat() API function, it is not feasible to render an OpenGL scene to a printer directly. A widely used technique is to render an OpenGL scene to a DIB section, then copy it to a DC for printing or print preview. This article demonstrates this approach.
(continued)
I use Document/View architecture in the demo. The view class CGLView is multiple-derived from CView and CGLObj. The later class bundles all the OpenGL implementation - including printing. The CGLView::OnPrint function wraps three methods as follows:
void CGLView::OnPrint(CDC* pDC, CPrintInfo* pInfo)
{ CGLObj::OnPrint1(pDC, pInfo, this);
OnDraw(pDC);
CGLObj::OnPrint2(pDC);
}
The CGLObj::OnPrint1 is designed to prepare for off-screen rendering. The major purposes of the method are to create a DIB section, and a memory RC. The memory RC will be used for OpenGL off-screen rendering later on. Following is the sequential of the method. After rendering, CGLObj::OnPrint2 copies the image in DIB section to the printer or preview DC, then releases the memory.
Preparing for OpenGL Off-Screen Rendering - OnPrint1()
- Determine the DIB size for either printing or print preview.
The size of the DIB section depends on the size of the display device. For print previewing, I use screen resolution. For printing, I use the reduced 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 to excess of 100MB. That is why I reduce the printing resolution.
- Create DIB Section
I call Windows function CreateDIBSection() to create a DIB section with this size mentioned above.
- Create memory DC, and associate it with the DIB section
Calling Win32 function CreateCompatibleDC() creates a memory DC and returns a handle of it. Then I select the DIB section into a memory DC.
- Setup memory DC's pixel format
Setting memory DC's pixel format is similar to setup a screen DC. The only difference is a flag specifying properties of the pixel buffer. I set PFD_DRAW_TO_WINDOW and PFD_DOUBLEBUFFER for the screen DC, but I need PFD_DRAW_TO_BITMAP for the memory DC. Thus, I made a helper function SetDCPixelFormat() to reuse this part of code.
- Create memory RC
I use the above memory DC to create a memory RC for OpenGL off-screen rendering. The life of memory DC and RC will end when the printing is finished.
- Store old DC and RC
The DC and RC for screen rendering should be stored. They will be restored after printing is finished.
- Make the memory RC current
The function wglMakeCurrent() sets the memory RC current. From now, OpenGL will render with the memory RC, not screen RC. However, before rendering with the memory RC, I have to initialize the RC just like that working with screen RC.
- Set OpenGL state for memory RC
The OpenGL state and frustum of the memory RC must be the same as the screen RC's so that we can get the same image rendered to the memory RC. I made SetOpenGLState() and SetFrustum() functions work for both RCs
- Create display list with the newly created memory RC.
If you use OpenGL display list, you must create it again with the newly created memory RC. Keep in mind the display list is not reusable across RCs.
Following is the source code of CGLObj::OnPrint1
void CGLObj::OnPrint1(CDC* pDC, CPrintInfo* pInfo, CView* pView)
{
CRect rcClient;
pView->GetClientRect(&rcClient);
float fClientRatio = float(rcClient.Height())/rcClient.Width();
m_szPage.cx = pDC->GetDeviceCaps(HORZRES);
m_szPage.cy = pDC->GetDeviceCaps(VERTRES);
CSize szDIB;
if (pInfo->m_bPreview)
{
szDIB.cx = rcClient.Width();
szDIB.cy = rcClient.Height();
}
else
{
if (m_szPage.cy > fClientRatio*m_szPage.cx)
{
szDIB.cx = m_szPage.cx;
szDIB.cy = long(fClientRatio*m_szPage.cx);
}
else
{
szDIB.cx = long(float(m_szPage.cy)/fClientRatio);
szDIB.cy = m_szPage.cy;
}
while (szDIB.cx*szDIB.cy > 20e6)
{
szDIB.cx = szDIB.cx/2;
szDIB.cy = szDIB.cy/2;
}
}
TRACE("Buffer size: %d x %d = %6.2f MB\n",
szDIB.cx, szDIB.cy, szDIB.cx*szDIB.cy*0.000001);
memset(&m_bmi, 0, sizeof(BITMAPINFO));
m_bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
m_bmi.bmiHeader.biWidth = szDIB.cx;
m_bmi.bmiHeader.biHeight = szDIB.cy;
m_bmi.bmiHeader.biPlanes = 1;
m_bmi.bmiHeader.biBitCount = 24;
m_bmi.bmiHeader.biCompression = BI_RGB;
m_bmi.bmiHeader.biSizeImage = szDIB.cx * szDIB.cy * 3;
HDC hDC = ::GetDC(pView->m_hWnd);
m_hDib = ::CreateDIBSection(hDC, &m_bmi, DIB_RGB_COLORS,
&m_pBitmapBits, NULL, (DWORD)0);
::ReleaseDC(pView->m_hWnd, hDC);
m_hMemDC = ::CreateCompatibleDC(NULL);
if (!m_hMemDC)
{
DeleteObject(m_hDib);
m_hDib = NULL;
return;
}
SelectObject(m_hMemDC, m_hDib);
if (!SetDCPixelFormat(m_hMemDC,
PFD_DRAW_TO_BITMAP
| PFD_SUPPORT_OPENGL
| PFD_STEREO_DONTCARE))
{
DeleteObject(m_hDib);
m_hDib = NULL;
DeleteDC(m_hMemDC);
m_hMemDC = NULL;
return;
}
m_hMemRC = ::wglCreateContext(m_hMemDC);
if (!m_hMemRC)
{
DeleteObject(m_hDib);
m_hDib = NULL;
DeleteDC(m_hMemDC);
m_hMemDC = NULL;
return;
}
m_hOldDC = ::wglGetCurrentDC();
m_hOldRC = ::wglGetCurrentContext();
::wglMakeCurrent(m_hMemDC, m_hMemRC);
SetOpenGLState();
::glViewport(0, 0, szDIB.cx, szDIB.cy);
SetFrustum();
CreateDisplayList(1);
}
Off-Screen Rendering
Now we can render with the memory RC. It is a common practice and a good idea to reuse the rendering scenario, but do not use double buffering for the memory RC.
Printing - OnPrint2()
This method handles the real "printing", and then free the memory.
- Release memory RC, and restore the old DC and RC.
After rendering, we can delete the memory RC right away, and restore the old DC and RC for screen rendering.
- Calculate the target size according to the image size, and orientation of the paper.
Now the image is stored in the memory, particularly in the DIB section. In general, the page size and orientation are different from the image's. We need to work out a target area on the page, to which the image will be copied. The target area should have the same orientation and elongation as the image in the DIB section.
- Stretch image to fit in the target size.
The Win32 API StretchDIBits() copies the image in the DIB section to the destination, a handle to DC for either printing or print preview. The image is stretched to fit in the target area with the same elongation.
- Release memory.
The job is finished. Release the memory for DIB section and memory DC now.
Following is the source code of CGLObj::OnPrint2
void CGLObj::OnPrint2(CDC* pDC)
{
::wglMakeCurrent(NULL, NULL);
::wglDeleteContext(m_hMemRC);
::wglMakeCurrent(m_hOldDC, m_hOldRC);
float fBmiRatio =
float(m_bmi.bmiHeader.biHeight) / m_bmi.bmiHeader.biWidth;
CSize szTarget;
if (m_szPage.cx > m_szPage.cy)
{
if(fBmiRatio<1)
{
szTarget.cx = m_szPage.cx;
szTarget.cy = long(fBmiRatio * m_szPage.cx);
}
else
{
szTarget.cx = long(m_szPage.cy/fBmiRatio);
szTarget.cy = m_szPage.cy;
}
}
else
{
if(fBmiRatio<1)
{
szTarget.cx = m_szPage.cx;
szTarget.cy = long(fBmiRatio * m_szPage.cx);
}
else
{
szTarget.cx = long(m_szPage.cy/fBmiRatio);
szTarget.cy = m_szPage.cy;
}
}
CSize szOffset((m_szPage.cx - szTarget.cx) / 2,
(m_szPage.cy - szTarget.cy) / 2);
int nRet = ::StretchDIBits(pDC->GetSafeHdc(),
szOffset.cx, szOffset.cy,
szTarget.cx, szTarget.cy,
0, 0,
m_bmi.bmiHeader.biWidth,
m_bmi.bmiHeader.biHeight,
GLubyte*) m_pBitmapBits,
m_bmi,
DIB_RGB_COLORS,
SRCCOPY);
if(nRet == GDI_ERROR)
TRACE0("Failed in StretchDIBits()");
DeleteObject(m_hDib);
m_hDib = NULL;
DeleteDC(m_hMemDC);
m_hMemDC = NULL;
m_hOldDC = NULL;
}
Notice
This demo requires at least 16 bit colors. If your computer displays blank in print preview, check out the color setting in the Control Panel.
Not all video cards work well with OpenGL. When you involve any problem, try with machines with different video chards.
Downloads
Download source - 37 Kb