GLBitmapBuffer.cpp

Go to the documentation of this file.

#include "standard.h"
#include "PortablePicture.h"
#include "GLBitmapBuffer.h"

GLBitmapBuffer::GLBitmapBuffer() 
{ 
    hdc = CreateCompatibleDC (NULL);
    assert(hdc);

    hBitmap = NULL;
    hBitmapOld = NULL;
    data = NULL; 
}


void GLBitmapBuffer::select()
{
    m_hrcOld = wglGetCurrentContext();
    hdcOld = wglGetCurrentDC();

    if (!wglMakeCurrent (hdc, m_hrc))
        throw Error ("GLBitmapBuffer::Select(): wglMakeCurrent() failure.");
}

void GLBitmapBuffer::unselect()
{
    wglMakeCurrent (hdcOld, m_hrcOld);
}

void GLBitmapBuffer::create(unsigned int w, unsigned int h)
{
/*
 * Create the bitmap DIB section itself
 */
   width = w;
   height = h;

   // Create a BITMAPINFOHEADER structure to describe the DIB
   BITMAPV4HEADER BIH ;
   int iSize = sizeof(BITMAPV4HEADER) ;
   memset(&BIH, 0, iSize);

   // Fill in the header info.
   BIH.bV4Size = iSize;
   BIH.bV4Width = width;
   BIH.bV4Height = height;
   BIH.bV4Planes = 1;
   BIH.bV4BitCount = 24;
   
#if 0
   BIH.bV4BitCount = 32;
   BIH.bV4V4Compression = BI_BITFIELDS;
   BIH.bV4RedMask = 0x00FF0000;
   BIH.bV4GreenMask = 0x0000FF00;
   BIH.bV4BlueMask = 0x000000FF;
   BIH.bV4AlphaMask = 0xFF000000;
#endif
   
   // Create the DIB section.
   hBitmap = CreateDIBSection( 
       hdc,
       (BITMAPINFO*)&BIH,
       DIB_RGB_COLORS,
       (void**)&data,
       NULL,
       0);
   
   assert (hBitmap);
   assert (data);

   hBitmapOld = (HBITMAP)::SelectObject(
       hdc,
       hBitmap);

/*
 * Create opengl context 
 */
   DWORD dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;

   //
        // Fill in the Pixel Format Descriptor
        //
   PIXELFORMATDESCRIPTOR pfd ;
   memset(&pfd,0, sizeof(PIXELFORMATDESCRIPTOR)) ;
   pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);  
   pfd.nVersion = 1 ;                           // Version number
   pfd.dwFlags =  dwFlags ;
   pfd.iPixelType = PFD_TYPE_RGBA ;
   pfd.cColorBits = (BYTE)24 ;
   pfd.cDepthBits = 32 ;                                                // 32-bit depth buffer
   pfd.iLayerType = PFD_MAIN_PLANE ;            // Layer type
#if 0
   pfd.cAlphaBits = 1;
#endif


   int nPixelFormat = ChoosePixelFormat (hdc, &pfd);

   if (!nPixelFormat)
        throw Error("GLBitmapBuffer::Create(): ChoosePixelFormat failure.");
   
   if (!SetPixelFormat (hdc, nPixelFormat, &pfd))
       throw Error("GLBitmapBuffer::Create(): SetPixelFormat failure.");
   
   m_hrc = wglCreateContext (hdc);
   
   if (!m_hrc)
       throw Error ("GLBitmapBuffer::Create(): wglCreateContext failure.");       
}

RgbByte *GLBitmapBuffer::operator[] (int index)
{
    return (RgbByte*)&data[index * width * 3];
}

GLBitmapBuffer::~GLBitmapBuffer()
{
    if (hBitmapOld)
        SelectObject (hdc, hBitmapOld);

    if (hBitmap)
        DeleteObject (hBitmap);

    if (hdc) 
        DeleteDC (hdc);

/* 
 * free opengl stuff
 */
    if (m_hrc == wglGetCurrentContext())
                wglMakeCurrent(NULL,NULL) ; 

        wglDeleteContext(m_hrc) ;
        m_hrc = NULL ;
}

void GLBitmapBuffer::saveAs (char *filename)
{
    PortablePixMap p;
    p.setDimensions (getWidth(), getHeight());
    memcpy (p[0], data, getWidth()*getHeight()*3);

    RGBTRIPLE *pic = (RGBTRIPLE*)p[0];
    for (unsigned int i = 0; i < getWidth()*getHeight(); i++)
    {
        std::swap (pic[i].rgbtBlue, pic[i].rgbtRed);
    }

    p.saveAs(filename);
}

---