Модификация примера работы с GLUT

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
 
#include <windows.h>
#include <GL/GL.h>
#include <iostream>
 
#define STR(text) #text
#define winApiCheck(expr, fail) do { if ((expr) == (fail)) checkError(__FILE__, __LINE__, STR(expr)); } while(false)
#define logger(...) getDefaultLogOutput(__VA_ARGS__)
//====================================================================================
std::ostream & getDefaultLogOutput() { return std::cerr; }
 
const char * getErrorStr(DWORD errCode);
 
void checkError(const char * file, int line, const char * expr);
//====================================================================================
class OffscreenSurface
{
public:
    OffscreenSurface();
 
    ~OffscreenSurface();
 
    bool create(HDC hdc, int width, int height);
 
    bool makeCurrent(bool current = true);
 
    void display();
 
    bool blit(HDC hdc, int x = 0, int y = 0);
 
    bool blit(HDC hdc, int x, int y, int width, int height);
 
private:
 
    bool createDeviceCtx(HDC hdc);
 
    bool createSurface(int width, int height);
 
    bool chooseFormat();
 
    bool createContext();
 
    void cleanUp();
    
    HDC m_dc;
    HBITMAP m_dib;
    HGLRC m_rc;
    int m_width;
    int m_height;
    void * m_pixels; 
};
//====================================================================================
int main()
{
    HWND consoleWindow = GetConsoleWindow();
    HDC consoleDC = GetDC(consoleWindow);
    int width = 256;
    int height = 256;
    OffscreenSurface surf;
    if (surf.create(consoleDC, width, height) && surf.makeCurrent())
    {
        std::cout << "press enter to draw triangle...";
        std::cin.get();
 
        glViewport(0, 0, width, height);
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_TRIANGLES);
            glColor3ub(0xff, 0x00, 0x00);
            glVertex2f(-1.0f, -1.0f);
            glColor3ub(0x00, 0xff, 0x00);
            glVertex2f(1.0f, -1.0f);
            glColor3ub(0x00, 0x00, 0xff);
            glVertex2f(0.0f, 1.0f);
        glEnd();
 
        surf.display();
        surf.blit(consoleDC);
    }
    ReleaseDC(consoleWindow, consoleDC);
 
    std::cout << "press enter to finish...";
    std::cin.get();
}
//====================================================================================
const char * getErrorStr(DWORD errCode)
{
    switch (errCode)
    {
        case ERROR_INVALID_PIXEL_FORMAT : return STR(ERROR_INVALID_PIXEL_FORMAT);
        case ERROR_NO_SYSTEM_RESOURCES : return STR(ERROR_NO_SYSTEM_RESOURCES);
        case ERROR_INVALID_DATA : return STR(ERROR_INVALID_DATA);
        case ERROR_INVALID_HANDLE : return STR(ERROR_INVALID_HANDLE);
        case ERROR_DC_NOT_FOUND : return STR(ERROR_DC_NOT_FOUND);
        default : return STR(N/A);
    }
}
 
void checkError(const char * file, int line, const char * expr)
{
    auto errCode = GetLastError();
    logger() << "ERROR: " << file << " : " << line << "\n\t"
             << "expression: " << expr << "\n\t"
             << "code: " << errCode << "\n\t"
             << "description: " << getErrorStr(errCode) << '\n';
}
 
OffscreenSurface::OffscreenSurface()
    : m_dc(NULL), m_dib(NULL), m_rc(NULL), m_width(0), m_height(0), m_pixels(NULL)
{
}
 
OffscreenSurface::~OffscreenSurface()
{
    cleanUp();
}
 
bool OffscreenSurface::create(HDC hdc, int width, int height)
{
    cleanUp();
    bool result = createDeviceCtx(hdc);
    result = result && createSurface(width, height);
    result = result && chooseFormat();
    result = result && createContext();
    return result;
}
 
bool OffscreenSurface::makeCurrent(bool current)
{
    bool result = false;
    winApiCheck(result = wglMakeCurrent(m_dc, current ? m_rc : NULL), false);
    return result;
}
 
void OffscreenSurface::display()
{
    glFinish();
}
 
bool OffscreenSurface::blit(HDC hdc, int x, int y)
{
    return blit(hdc, x, y, m_width, m_height);
}
 
bool OffscreenSurface::blit(HDC hdc, int x, int y, int width, int height)
{
    bool result = false;
    winApiCheck(result = BitBlt(hdc, x, y, width, height, m_dc, 0, 0, SRCCOPY), false);
    return result;
}
 
bool OffscreenSurface::createDeviceCtx(HDC hdc)
{
    winApiCheck(m_dc = CreateCompatibleDC(hdc), NULL);
    return m_dc != NULL;
}
 
bool OffscreenSurface::createSurface(int width, int height)
{
    m_width = width;
    m_height = height;
 
    BITMAPINFO bmi;
    ZeroMemory(&bmi, sizeof(bmi));
    BITMAPINFOHEADER &bih = bmi.bmiHeader;
    bih.biSize = sizeof(BITMAPINFOHEADER);
    bih.biWidth = width;
    bih.biHeight = width;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
 
    winApiCheck(m_dib = CreateDIBSection(m_dc, &bmi, DIB_RGB_COLORS, &m_pixels, NULL, 0), NULL);
    HGDIOBJ result = NULL;
    if (m_dib)
        winApiCheck(result = SelectObject(m_dc, m_dib), NULL);
    return result != NULL;
}
 
bool OffscreenSurface::chooseFormat()
{
    PIXELFORMATDESCRIPTOR pfd;
    ZeroMemory(&pfd, sizeof(pfd));
    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 32;
    int format = 0;
    winApiCheck(format = ChoosePixelFormat(m_dc, &pfd), 0);
    bool result = (format != 0);
    if (result)
        winApiCheck(result = SetPixelFormat(m_dc, format, &pfd), false);
    return result;
}
 
bool OffscreenSurface::createContext()
{
    winApiCheck(m_rc = wglCreateContext(m_dc), NULL);
    return m_rc != NULL;
}
 
void OffscreenSurface::cleanUp()
{
    m_width = m_height = 0;
    if (m_rc != NULL)
    {
        makeCurrent(false);
        winApiCheck(wglDeleteContext(m_rc), FALSE);
        m_rc = NULL;
    }
    if (m_dib != NULL)
    {
        winApiCheck(DeleteObject(m_dib), FALSE);
        m_dib = NULL;
        m_pixels = NULL;
    }
    if (m_dc != NULL)
    {
        winApiCheck(DeleteDC(m_dc), FALSE);
        m_dc = NULL;
    }
}