mmozeiko/win32_opengl_multi.c

## win32_opengl_multi.c
// example how to set up OpenGL core context on Windows for rendering to multiple windows

#define WINDOW_COUNT 4 // how many windows we'll be opening?

// important extension functionality used here:
// (4.3) KHR_debug:                     https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_debug.txt
// (4.5) ARB_direct_state_access:       https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_direct_state_access.txt
// (4.1) ARB_separate_shader_objects:   https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_separate_shader_objects.txt
// (4.2) ARB_shading_language_420pack:  https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_420pack.txt
// (4.3) ARB_explicit_uniform_location: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_explicit_uniform_location.txt

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <GL/gl.h>
#include "glcorearb.h"  // download from https://www.khronos.org/registry/OpenGL/api/GL/glcorearb.h
#include "wglext.h"     // download from https://www.khronos.org/registry/OpenGL/api/GL/wglext.h
// also download https://www.khronos.org/registry/EGL/api/KHR/khrplatform.h and put in "KHR" folder

#define _USE_MATH_DEFINES
#include <math.h>
#include <stddef.h>

// replace this with your favorite Assert() implementation
#include <intrin.h>
#define Assert(cond) do { if (!(cond)) __debugbreak(); } while (0)

#pragma comment (lib, "gdi32.lib")
#pragma comment (lib, "user32.lib")
#pragma comment (lib, "opengl32.lib")

// make sure you use functions that are valid for selected GL version (specified when context is created)
#define GL_FUNCTIONS(X) \
    X(PFNGLCREATEBUFFERSPROC,            glCreateBuffers            ) \
    X(PFNGLNAMEDBUFFERSTORAGEPROC,       glNamedBufferStorage       ) \
    X(PFNGLBINDVERTEXARRAYPROC,          glBindVertexArray          ) \
    X(PFNGLCREATEVERTEXARRAYSPROC,       glCreateVertexArrays       ) \
    X(PFNGLVERTEXARRAYATTRIBBINDINGPROC, glVertexArrayAttribBinding ) \
    X(PFNGLVERTEXARRAYVERTEXBUFFERPROC,  glVertexArrayVertexBuffer  ) \
    X(PFNGLVERTEXARRAYATTRIBFORMATPROC,  glVertexArrayAttribFormat  ) \
    X(PFNGLENABLEVERTEXARRAYATTRIBPROC,  glEnableVertexArrayAttrib  ) \
    X(PFNGLCREATESHADERPROGRAMVPROC,     glCreateShaderProgramv     ) \
    X(PFNGLGETPROGRAMIVPROC,             glGetProgramiv             ) \
    X(PFNGLGETPROGRAMINFOLOGPROC,        glGetProgramInfoLog        ) \
    X(PFNGLGENPROGRAMPIPELINESPROC,      glGenProgramPipelines      ) \
    X(PFNGLUSEPROGRAMSTAGESPROC,         glUseProgramStages         ) \
    X(PFNGLBINDPROGRAMPIPELINEPROC,      glBindProgramPipeline      ) \
    X(PFNGLPROGRAMUNIFORMMATRIX2FVPROC,  glProgramUniformMatrix2fv  ) \
    X(PFNGLBINDTEXTUREUNITPROC,          glBindTextureUnit          ) \
    X(PFNGLCREATETEXTURESPROC,           glCreateTextures           ) \
    X(PFNGLTEXTUREPARAMETERIPROC,        glTextureParameteri        ) \
    X(PFNGLTEXTURESTORAGE2DPROC,         glTextureStorage2D         ) \
    X(PFNGLTEXTURESUBIMAGE2DPROC,        glTextureSubImage2D        ) \
    X(PFNGLDEBUGMESSAGECALLBACKPROC,     glDebugMessageCallback     )

#define X(type, name) static type name;
GL_FUNCTIONS(X)
#undef X

#define STR2(x) #x
#define STR(x) STR2(x)

static void FatalError(const char* message)
{
    MessageBoxA(NULL, message, "Error", MB_ICONEXCLAMATION);
    ExitProcess(0);
}

#ifndef NDEBUG
static void APIENTRY DebugCallback(
    GLenum source, GLenum type, GLuint id, GLenum severity,
    GLsizei length, const GLchar* message, const void* user)
{
    OutputDebugStringA(message);
    OutputDebugStringA("\n");
    if (severity == GL_DEBUG_SEVERITY_HIGH || severity == GL_DEBUG_SEVERITY_MEDIUM)
    {
        if (IsDebuggerPresent())
        {
            Assert(!"OpenGL error - check the callstack in debugger");
        }
        FatalError("OpenGL API usage error! Use debugger to examine call stack!");
    }
}
#endif

static LRESULT CALLBACK WindowProc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg)
    {
    case WM_DESTROY:
        // closing any of windows will make application to terminate
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(wnd, msg, wparam, lparam);
}

// compares src string with dstlen characters from dst, returns 1 if they are equal, 0 if not
static int StringsAreEqual(const char* src, const char* dst, size_t dstlen)
{
    while (*src && dstlen-- && *dst)
    {
        if (*src++ != *dst++)
        {
            return 0;
        }
    }

    return (dstlen && *src == *dst) || (!dstlen && *src == 0);
}

static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = NULL;
static PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL;
static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;

static void GetWglFunctions(void)
{
    // to get WGL functions we need valid GL context, so create dummy window for dummy GL contetx
    HWND dummy = CreateWindowExW(
        0, L"STATIC", L"DummyWindow", WS_OVERLAPPED,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, NULL, NULL);
    Assert(dummy && "Failed to create dummy window");

    HDC dc = GetDC(dummy);
    Assert(dc && "Failed to get device context for dummy window");

    PIXELFORMATDESCRIPTOR desc =
    {
        .nSize = sizeof(desc),
        .nVersion = 1,
        .dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
        .iPixelType = PFD_TYPE_RGBA,
        .cColorBits = 24,
    };

    int format = ChoosePixelFormat(dc, &desc);
    if (!format)
    {
        FatalError("Cannot choose OpenGL pixel format for dummy window!");
    }

    int ok = DescribePixelFormat(dc, format, sizeof(desc), &desc);
    Assert(ok && "Failed to describe OpenGL pixel format");

    // reason to create dummy window is that SetPixelFormat can be called only once for the window
    if (!SetPixelFormat(dc, format, &desc))
    {
        FatalError("Cannot set OpenGL pixel format for dummy window!");
    }

    HGLRC rc = wglCreateContext(dc);
    Assert(rc && "Failed to create OpenGL context for dummy window");

    ok = wglMakeCurrent(dc, rc);
    Assert(ok && "Failed to make current OpenGL context for dummy window");

    // https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_extensions_string.txt
    PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
        (void*)wglGetProcAddress("wglGetExtensionsStringARB");
    if (!wglGetExtensionsStringARB)
    {
        FatalError("OpenGL does not support WGL_ARB_extensions_string extension!");
    }

    const char* ext = wglGetExtensionsStringARB(dc);
    Assert(ext && "Failed to get OpenGL WGL extension string");

    const char* start = ext;
    for (;;)
    {
        while (*ext != 0 && *ext != ' ')
        {
            ext++;
        }

        size_t length = ext - start;
        if (StringsAreEqual("WGL_ARB_pixel_format", start, length))
        {
            // https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_pixel_format.txt
            wglChoosePixelFormatARB = (void*)wglGetProcAddress("wglChoosePixelFormatARB");
        }
        else if (StringsAreEqual("WGL_ARB_create_context", start, length))
        {
            // https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_create_context.txt
            wglCreateContextAttribsARB = (void*)wglGetProcAddress("wglCreateContextAttribsARB");
        }
        else if (StringsAreEqual("WGL_EXT_swap_control", start, length))
        {
            // https://www.khronos.org/registry/OpenGL/extensions/EXT/WGL_EXT_swap_control.txt
            wglSwapIntervalEXT = (void*)wglGetProcAddress("wglSwapIntervalEXT");
        }

        if (*ext == 0)
        {
            break;
        }

        ext++;
        start = ext;
    }

    if (!wglChoosePixelFormatARB || !wglCreateContextAttribsARB || !wglSwapIntervalEXT)
    {
        FatalError("OpenGL does not support required WGL extensions for modern context!");
    }

    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(rc);
    ReleaseDC(dummy, dc);
    DestroyWindow(dummy);
}

int WINAPI WinMain(HINSTANCE instance, HINSTANCE previnstance, LPSTR cmdline, int cmdshow)
{
    // get WGL functions to be able to create modern GL context
    GetWglFunctions();

    // register window class to have custom WindowProc callback
    WNDCLASSEXW wc =
    {
        .cbSize = sizeof(wc),
        .lpfnWndProc = WindowProc,
        .hInstance = instance,
        .hIcon = LoadIcon(NULL, IDI_APPLICATION),
        .hCursor = LoadCursor(NULL, IDC_ARROW),
        .lpszClassName = L"opengl_window_class",
    };
    ATOM atom = RegisterClassExW(&wc);
    Assert(atom && "Failed to register window class");

    // window properties - width, height and style
    int width = 640;
    int height = 480;
    DWORD exstyle = WS_EX_APPWINDOW;
    DWORD style = WS_OVERLAPPEDWINDOW;

    // uncomment in case you want fixed size window
    //style &= ~WS_THICKFRAME & ~WS_MAXIMIZEBOX;
    //RECT rect = { 0, 0, 1280, 720 };
    //AdjustWindowRectEx(&rect, style, FALSE, exstyle);
    //width = rect.right - rect.left;
    //height = rect.bottom - rect.top;

    // we'll use only one OpenGL context for simplicity, no need to worry about resource sharing
    HGLRC rc = NULL;

    // VERY IMPORTANT: all windows sharing same OpenGL context must have same pixel format
    // this is mentioned in https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_create_context.txt
    int format = 0;
    PIXELFORMATDESCRIPTOR desc = { .nSize = sizeof(desc) };

    HWND windows[WINDOW_COUNT];
    HDC dcs[WINDOW_COUNT];

    // create requested amount of  windows
    for (int wi=0; wi<WINDOW_COUNT; wi++)
    {
        // create window
        HWND window = CreateWindowExW(
            exstyle, wc.lpszClassName, L"OpenGL Window", style,
            CW_USEDEFAULT, CW_USEDEFAULT, width, height,
            NULL, NULL, wc.hInstance, NULL);
        Assert(window && "Failed to create window");

        HDC dc = GetDC(window);
        Assert(dc && "Failed to window device context");

        if (format == 0)
        {
            // figure out pixel format
            int attrib[] =
            {
                WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
                WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
                WGL_DOUBLE_BUFFER_ARB,  GL_TRUE,
                WGL_PIXEL_TYPE_ARB,     WGL_TYPE_RGBA_ARB,
                WGL_COLOR_BITS_ARB,     24,
                WGL_DEPTH_BITS_ARB,     24,
                WGL_STENCIL_BITS_ARB,   8,

                // uncomment for sRGB framebuffer, from WGL_ARB_framebuffer_sRGB extension
                // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_framebuffer_sRGB.txt
                //WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, GL_TRUE,

                // uncomment for multisampeld framebuffer, from WGL_ARB_multisample extension
                // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_multisample.txt
                //WGL_SAMPLE_BUFFERS_ARB, 1,
                //WGL_SAMPLES_ARB,        4, // 4x MSAA

                0,
            };

            UINT formats;
            if (!wglChoosePixelFormatARB(dc, attrib, NULL, 1, &format, &formats) || formats == 0)
            {
                FatalError("OpenGL does not support required pixel format!");
            }

            int ok = DescribePixelFormat(dc, format, sizeof(desc), &desc);
            Assert(ok && "Failed to describe OpenGL pixel format");
        }

        // always set pixel format, same for all windows
        if (!SetPixelFormat(dc, format, &desc))
        {
           FatalError("Cannot set OpenGL selected pixel format!");
        }

        // now create modern OpenGL context, can do it after pixel format is set
        if (rc == NULL)
        {
            int attrib[] =
            {
                WGL_CONTEXT_MAJOR_VERSION_ARB, 4,
                WGL_CONTEXT_MINOR_VERSION_ARB, 5,
                WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
#ifndef NDEBUG
                // ask for debug context for non "Release" builds
                // this is so we can enable debug callback
                WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
#endif
                0,
            };

            rc = wglCreateContextAttribsARB(dc, NULL, attrib);
            if (!rc)
            {
                FatalError("Cannot create modern OpenGL context! OpenGL version 4.5 not supported?");
            }

            BOOL ok = wglMakeCurrent(dc, rc);
            Assert(ok && "Failed to make current OpenGL context");

            // load OpenGL functions
#define X(type, name) name = (type)wglGetProcAddress(#name); Assert(name);
            GL_FUNCTIONS(X)
#undef X

#ifndef NDEBUG
            // enable debug callback
            glDebugMessageCallback(&DebugCallback, NULL);
            glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
        }

        windows[wi] = window;
        dcs[wi] = dc;
    }

    struct Vertex
    {
        float position[2];
        float uv[2];
        float color[3];
    };

    // vertex buffer containing triangle vertices
    GLuint vbo;
    {
        struct Vertex data[] =
        {
            { { -0.00f, +0.75f }, { 25.0f, 50.0f }, { 1, 0, 0 } },
            { { +0.75f, -0.50f }, {  0.0f,  0.0f }, { 0, 1, 0 } },
            { { -0.75f, -0.50f }, { 50.0f,  0.0f }, { 0, 0, 1 } },
        };
        glCreateBuffers(1, &vbo);
        glNamedBufferStorage(vbo, sizeof(data), data, 0);
    }

    // vertex input
    GLuint vao;
    {
        glCreateVertexArrays(1, &vao);

        GLint vbuf_index = 0;
        glVertexArrayVertexBuffer(vao, vbuf_index, vbo, 0, sizeof(struct Vertex));

        GLint a_pos = 0;
        glVertexArrayAttribFormat(vao, a_pos, 2, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, position));
        glVertexArrayAttribBinding(vao, a_pos, vbuf_index);
        glEnableVertexArrayAttrib(vao, a_pos);

        GLint a_uv = 1;
        glVertexArrayAttribFormat(vao, a_uv, 2, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, uv));
        glVertexArrayAttribBinding(vao, a_uv, vbuf_index);
        glEnableVertexArrayAttrib(vao, a_uv);

        GLint a_color = 2;
        glVertexArrayAttribFormat(vao, a_color, 3, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, color));
        glVertexArrayAttribBinding(vao, a_color, vbuf_index);
        glEnableVertexArrayAttrib(vao, a_color);
    }

    // checkerboard texture, with 50% transparency on black colors
    GLuint texture;
    {
        unsigned int pixels[] =
        {
            0x80000000, 0xffffffff,
            0xffffffff, 0x80000000,
        };

        glCreateTextures(GL_TEXTURE_2D, 1, &texture);
        glTextureParameteri(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTextureParameteri(texture, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTextureParameteri(texture, GL_TEXTURE_WRAP_T, GL_REPEAT);

        GLsizei width = 2;
        GLsizei height = 2;
        glTextureStorage2D(texture, 1, GL_RGBA8, width, height);
        glTextureSubImage2D(texture, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
    }

    // fragment & vertex shaders for drawing triangle
    GLuint pipeline, vshader, fshader;
    {
        const char* glsl_vshader =
            "#version 450 core                             \n"
            "#line " STR(__LINE__) "                     \n\n" // actual line number in this file for nicer error messages
            "                                              \n"
            "layout (location=0) in vec2 a_pos;            \n" // position attribute index 0
            "layout (location=1) in vec2 a_uv;             \n" // uv attribute index 1
            "layout (location=2) in vec3 a_color;          \n" // color attribute index 2
            "                                              \n"
            "layout (location=0)                           \n" // (from ARB_explicit_uniform_location)
            "uniform mat2 u_matrix;                        \n" // matrix uniform location 0
            "                                              \n"
            "out gl_PerVertex { vec4 gl_Position; };       \n" // required because of ARB_separate_shader_objects
            "out vec2 uv;                                  \n"
            "out vec4 color;                               \n"
            "                                              \n"
            "void main()                                   \n"
            "{                                             \n"
            "    vec2 pos = u_matrix * a_pos;              \n"
            "    gl_Position = vec4(pos, 0, 1);            \n"
            "    uv = a_uv;                                \n"
            "    color = vec4(a_color, 1);                 \n"
            "}                                             \n"
        ;

        const char* glsl_fshader =
            "#version 450 core                             \n"
            "#line " STR(__LINE__) "                     \n\n" // actual line number in this file for nicer error messages
            "                                              \n"
            "in vec2 uv;                                   \n"
            "in vec4 color;                                \n"
            "                                              \n"
            "layout (binding=0)                            \n" // (from ARB_shading_language_420pack)
            "uniform sampler2D s_texture;                  \n" // texture unit binding 0
            "                                              \n"
            "layout (location=0)                           \n"
            "out vec4 o_color;                             \n" // output fragment data location 0
            "                                              \n"
            "void main()                                   \n"
            "{                                             \n"
            "    o_color = color * texture(s_texture, uv); \n"
            "}                                             \n"
        ;

        vshader = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vshader);
        fshader = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fshader);

        GLint linked;
        glGetProgramiv(vshader, GL_LINK_STATUS, &linked);
        if (!linked)
        {
            char message[1024];
            glGetProgramInfoLog(vshader, sizeof(message), NULL, message);
            OutputDebugStringA(message);
            Assert(!"Failed to create vertex shader!");
        }

        glGetProgramiv(fshader, GL_LINK_STATUS, &linked);
        if (!linked)
        {
            char message[1024];
            glGetProgramInfoLog(fshader, sizeof(message), NULL, message);
            OutputDebugStringA(message);
            Assert(!"Failed to create fragment shader!");
        }

        glGenProgramPipelines(1, &pipeline);
        glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, vshader);
        glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, fshader);
    }

    // setup global GL state
    {
        // enable alpha blending
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // disble depth testing
        glDisable(GL_DEPTH_TEST);

        // disable culling
        glDisable(GL_CULL_FACE);
    }

    // set to FALSE to disable vsync
    BOOL vsync = TRUE;
    wglSwapIntervalEXT(vsync ? 1 : 0);

    // show all windows once all OpenGL state is set up
    for (int wi=0; wi<WINDOW_COUNT; wi++)
    {
        ShowWindow(windows[wi], SW_SHOWDEFAULT);
    }

    LARGE_INTEGER freq, c1;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&c1);

    float angles[WINDOW_COUNT] = { 0 };

    for (;;)
    {
        // process all incoming Windows messages
        MSG msg;
        if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT)
            {
                break;
            }
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
            continue;
        }

        LARGE_INTEGER c2;
        QueryPerformanceCounter(&c2);
        float delta = (float)((double)(c2.QuadPart - c1.QuadPart) / freq.QuadPart);
        c1 = c2;

        // we'll be rendering same thing to all windows
        for (int wi=0; wi<WINDOW_COUNT; wi++)
        {
            HWND window = windows[wi];
            HDC dc = dcs[wi];

            // activate OpenGL context for device context where we'll be drawing
            BOOL ok = wglMakeCurrent(dc, rc);
            Assert(ok && "Failed to make current OpenGL context");

            // get current window client area size
            RECT rect;
            GetClientRect(window, &rect);
            width = rect.right - rect.left;
            height = rect.bottom - rect.top;

            // render only if window size is non-zero
            if (width != 0 && height != 0)
            {
                // setup output size covering all client area of window
                glViewport(0, 0, width, height);

                // clear screen
                glClearColor(0.392f, 0.584f, 0.929f, 1.f);
                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

                // setup rotation matrix in uniform
                {
                    // different windows will have triangle rotated in different speed
                    angles[wi] += delta * 2.0f * (float)M_PI / (10.f + 5.f * wi);
                    angles[wi] = fmodf(angles[wi], 2.0f * (float)M_PI);
                    float angle = angles[wi];

                    float aspect = (float)height / width;
                    float matrix[] =
                    {
                        cosf(angle) * aspect, -sinf(angle),
                        sinf(angle) * aspect,  cosf(angle),
                    };

                    GLint u_matrix = 0;
                    glProgramUniformMatrix2fv(vshader, u_matrix, 1, GL_FALSE, matrix);
                }

                // activate shaders for next draw call
                glBindProgramPipeline(pipeline);

                // provide vertex input
                glBindVertexArray(vao);

                // bind texture to texture unit
                GLint s_texture = 0; // texture unit that sampler2D will use in GLSL code
                glBindTextureUnit(s_texture, texture);

                // draw 3 vertices as triangle
                glDrawArrays(GL_TRIANGLES, 0, 3);

                // flush all pending OpenGL commands, as we'll be switching to different window
                glFlush();
            }
            else
            {
                // no need to render, window is minimized
            }
        }

        // when all OpenGL commands are submitted, we swap buffers for all windows
        for (int wi=0; wi<WINDOW_COUNT; wi++)
        {
            if (!SwapBuffers(dcs[wi]))
            {
                FatalError("Failed to swap OpenGL buffers!");
            }
        }
    }
}
	// example how to set up OpenGL core context on Windows for rendering to multiple windows

	#define WINDOW_COUNT 4 // how many windows we'll be opening?

	// important extension functionality used here:
	// (4.3) KHR_debug: https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_debug.txt
	// (4.5) ARB_direct_state_access: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_direct_state_access.txt
	// (4.1) ARB_separate_shader_objects: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_separate_shader_objects.txt
	// (4.2) ARB_shading_language_420pack: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_shading_language_420pack.txt
	// (4.3) ARB_explicit_uniform_location: https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_explicit_uniform_location.txt

	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>

	#include <GL/gl.h>
	#include "glcorearb.h" // download from https://www.khronos.org/registry/OpenGL/api/GL/glcorearb.h
	#include "wglext.h" // download from https://www.khronos.org/registry/OpenGL/api/GL/wglext.h
	// also download https://www.khronos.org/registry/EGL/api/KHR/khrplatform.h and put in "KHR" folder

	#define _USE_MATH_DEFINES
	#include <math.h>
	#include <stddef.h>

	// replace this with your favorite Assert() implementation
	#include <intrin.h>
	#define Assert(cond) do { if (!(cond)) __debugbreak(); } while (0)

	#pragma comment (lib, "gdi32.lib")
	#pragma comment (lib, "user32.lib")
	#pragma comment (lib, "opengl32.lib")

	// make sure you use functions that are valid for selected GL version (specified when context is created)
	#define GL_FUNCTIONS(X) \
	X(PFNGLCREATEBUFFERSPROC, glCreateBuffers ) \
	X(PFNGLNAMEDBUFFERSTORAGEPROC, glNamedBufferStorage ) \
	X(PFNGLBINDVERTEXARRAYPROC, glBindVertexArray ) \
	X(PFNGLCREATEVERTEXARRAYSPROC, glCreateVertexArrays ) \
	X(PFNGLVERTEXARRAYATTRIBBINDINGPROC, glVertexArrayAttribBinding ) \
	X(PFNGLVERTEXARRAYVERTEXBUFFERPROC, glVertexArrayVertexBuffer ) \
	X(PFNGLVERTEXARRAYATTRIBFORMATPROC, glVertexArrayAttribFormat ) \
	X(PFNGLENABLEVERTEXARRAYATTRIBPROC, glEnableVertexArrayAttrib ) \
	X(PFNGLCREATESHADERPROGRAMVPROC, glCreateShaderProgramv ) \
	X(PFNGLGETPROGRAMIVPROC, glGetProgramiv ) \
	X(PFNGLGETPROGRAMINFOLOGPROC, glGetProgramInfoLog ) \
	X(PFNGLGENPROGRAMPIPELINESPROC, glGenProgramPipelines ) \
	X(PFNGLUSEPROGRAMSTAGESPROC, glUseProgramStages ) \
	X(PFNGLBINDPROGRAMPIPELINEPROC, glBindProgramPipeline ) \
	X(PFNGLPROGRAMUNIFORMMATRIX2FVPROC, glProgramUniformMatrix2fv ) \
	X(PFNGLBINDTEXTUREUNITPROC, glBindTextureUnit ) \
	X(PFNGLCREATETEXTURESPROC, glCreateTextures ) \
	X(PFNGLTEXTUREPARAMETERIPROC, glTextureParameteri ) \
	X(PFNGLTEXTURESTORAGE2DPROC, glTextureStorage2D ) \
	X(PFNGLTEXTURESUBIMAGE2DPROC, glTextureSubImage2D ) \
	X(PFNGLDEBUGMESSAGECALLBACKPROC, glDebugMessageCallback )

	#define X(type, name) static type name;
	GL_FUNCTIONS(X)
	#undef X

	#define STR2(x) #x
	#define STR(x) STR2(x)

	static void FatalError(const char* message)
	{
	MessageBoxA(NULL, message, "Error", MB_ICONEXCLAMATION);
	ExitProcess(0);
	}

	#ifndef NDEBUG
	static void APIENTRY DebugCallback(
	GLenum source, GLenum type, GLuint id, GLenum severity,
	GLsizei length, const GLchar* message, const void* user)
	{
	OutputDebugStringA(message);
	OutputDebugStringA("\n");
	if (severity == GL_DEBUG_SEVERITY_HIGH \|\| severity == GL_DEBUG_SEVERITY_MEDIUM)
	{
	if (IsDebuggerPresent())
	{
	Assert(!"OpenGL error - check the callstack in debugger");
	}
	FatalError("OpenGL API usage error! Use debugger to examine call stack!");
	}
	}
	#endif

	static LRESULT CALLBACK WindowProc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam)
	{
	switch (msg)
	{
	case WM_DESTROY:
	// closing any of windows will make application to terminate
	PostQuitMessage(0);
	return 0;
	}
	return DefWindowProcW(wnd, msg, wparam, lparam);
	}

	// compares src string with dstlen characters from dst, returns 1 if they are equal, 0 if not
	static int StringsAreEqual(const char* src, const char* dst, size_t dstlen)
	{
	while (src && dstlen-- && dst)
	{
	if (src++ != dst++)
	{
	return 0;
	}
	}

	return (dstlen && src == dst) \|\| (!dstlen && *src == 0);
	}

	static PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = NULL;
	static PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = NULL;
	static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL;

	static void GetWglFunctions(void)
	{
	// to get WGL functions we need valid GL context, so create dummy window for dummy GL contetx
	HWND dummy = CreateWindowExW(
	0, L"STATIC", L"DummyWindow", WS_OVERLAPPED,
	CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
	NULL, NULL, NULL, NULL);
	Assert(dummy && "Failed to create dummy window");

	HDC dc = GetDC(dummy);
	Assert(dc && "Failed to get device context for dummy window");

	PIXELFORMATDESCRIPTOR desc =
	{
	.nSize = sizeof(desc),
	.nVersion = 1,
	.dwFlags = PFD_DRAW_TO_WINDOW \| PFD_SUPPORT_OPENGL \| PFD_DOUBLEBUFFER,
	.iPixelType = PFD_TYPE_RGBA,
	.cColorBits = 24,
	};

	int format = ChoosePixelFormat(dc, &desc);
	if (!format)
	{
	FatalError("Cannot choose OpenGL pixel format for dummy window!");
	}

	int ok = DescribePixelFormat(dc, format, sizeof(desc), &desc);
	Assert(ok && "Failed to describe OpenGL pixel format");

	// reason to create dummy window is that SetPixelFormat can be called only once for the window
	if (!SetPixelFormat(dc, format, &desc))
	{
	FatalError("Cannot set OpenGL pixel format for dummy window!");
	}

	HGLRC rc = wglCreateContext(dc);
	Assert(rc && "Failed to create OpenGL context for dummy window");

	ok = wglMakeCurrent(dc, rc);
	Assert(ok && "Failed to make current OpenGL context for dummy window");

	// https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_extensions_string.txt
	PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB =
	(void*)wglGetProcAddress("wglGetExtensionsStringARB");
	if (!wglGetExtensionsStringARB)
	{
	FatalError("OpenGL does not support WGL_ARB_extensions_string extension!");
	}

	const char* ext = wglGetExtensionsStringARB(dc);
	Assert(ext && "Failed to get OpenGL WGL extension string");

	const char* start = ext;
	for (;;)
	{
	while (ext != 0 && ext != ' ')
	{
	ext++;
	}

	size_t length = ext - start;
	if (StringsAreEqual("WGL_ARB_pixel_format", start, length))
	{
	// https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_pixel_format.txt
	wglChoosePixelFormatARB = (void*)wglGetProcAddress("wglChoosePixelFormatARB");
	}
	else if (StringsAreEqual("WGL_ARB_create_context", start, length))
	{
	// https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_create_context.txt
	wglCreateContextAttribsARB = (void*)wglGetProcAddress("wglCreateContextAttribsARB");
	}
	else if (StringsAreEqual("WGL_EXT_swap_control", start, length))
	{
	// https://www.khronos.org/registry/OpenGL/extensions/EXT/WGL_EXT_swap_control.txt
	wglSwapIntervalEXT = (void*)wglGetProcAddress("wglSwapIntervalEXT");
	}

	if (*ext == 0)
	{
	break;
	}

	ext++;
	start = ext;
	}

	if (!wglChoosePixelFormatARB \|\| !wglCreateContextAttribsARB \|\| !wglSwapIntervalEXT)
	{
	FatalError("OpenGL does not support required WGL extensions for modern context!");
	}

	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(rc);
	ReleaseDC(dummy, dc);
	DestroyWindow(dummy);
	}

	int WINAPI WinMain(HINSTANCE instance, HINSTANCE previnstance, LPSTR cmdline, int cmdshow)
	{
	// get WGL functions to be able to create modern GL context
	GetWglFunctions();

	// register window class to have custom WindowProc callback
	WNDCLASSEXW wc =
	{
	.cbSize = sizeof(wc),
	.lpfnWndProc = WindowProc,
	.hInstance = instance,
	.hIcon = LoadIcon(NULL, IDI_APPLICATION),
	.hCursor = LoadCursor(NULL, IDC_ARROW),
	.lpszClassName = L"opengl_window_class",
	};
	ATOM atom = RegisterClassExW(&wc);
	Assert(atom && "Failed to register window class");

	// window properties - width, height and style
	int width = 640;
	int height = 480;
	DWORD exstyle = WS_EX_APPWINDOW;
	DWORD style = WS_OVERLAPPEDWINDOW;

	// uncomment in case you want fixed size window
	//style &= ~WS_THICKFRAME & ~WS_MAXIMIZEBOX;
	//RECT rect = { 0, 0, 1280, 720 };
	//AdjustWindowRectEx(&rect, style, FALSE, exstyle);
	//width = rect.right - rect.left;
	//height = rect.bottom - rect.top;

	// we'll use only one OpenGL context for simplicity, no need to worry about resource sharing
	HGLRC rc = NULL;

	// VERY IMPORTANT: all windows sharing same OpenGL context must have same pixel format
	// this is mentioned in https://www.khronos.org/registry/OpenGL/extensions/ARB/WGL_ARB_create_context.txt
	int format = 0;
	PIXELFORMATDESCRIPTOR desc = { .nSize = sizeof(desc) };

	HWND windows[WINDOW_COUNT];
	HDC dcs[WINDOW_COUNT];

	// create requested amount of windows
	for (int wi=0; wi<WINDOW_COUNT; wi++)
	{
	// create window
	HWND window = CreateWindowExW(
	exstyle, wc.lpszClassName, L"OpenGL Window", style,
	CW_USEDEFAULT, CW_USEDEFAULT, width, height,
	NULL, NULL, wc.hInstance, NULL);
	Assert(window && "Failed to create window");

	HDC dc = GetDC(window);
	Assert(dc && "Failed to window device context");

	if (format == 0)
	{
	// figure out pixel format
	int attrib[] =
	{
	WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
	WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
	WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
	WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
	WGL_COLOR_BITS_ARB, 24,
	WGL_DEPTH_BITS_ARB, 24,
	WGL_STENCIL_BITS_ARB, 8,

	// uncomment for sRGB framebuffer, from WGL_ARB_framebuffer_sRGB extension
	// https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_framebuffer_sRGB.txt
	//WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, GL_TRUE,

	// uncomment for multisampeld framebuffer, from WGL_ARB_multisample extension
	// https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_multisample.txt
	//WGL_SAMPLE_BUFFERS_ARB, 1,
	//WGL_SAMPLES_ARB, 4, // 4x MSAA

	0,
	};

	UINT formats;
	if (!wglChoosePixelFormatARB(dc, attrib, NULL, 1, &format, &formats) \|\| formats == 0)
	{
	FatalError("OpenGL does not support required pixel format!");
	}

	int ok = DescribePixelFormat(dc, format, sizeof(desc), &desc);
	Assert(ok && "Failed to describe OpenGL pixel format");
	}

	// always set pixel format, same for all windows
	if (!SetPixelFormat(dc, format, &desc))
	{
	FatalError("Cannot set OpenGL selected pixel format!");
	}

	// now create modern OpenGL context, can do it after pixel format is set
	if (rc == NULL)
	{
	int attrib[] =
	{
	WGL_CONTEXT_MAJOR_VERSION_ARB, 4,
	WGL_CONTEXT_MINOR_VERSION_ARB, 5,
	WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
	#ifndef NDEBUG
	// ask for debug context for non "Release" builds
	// this is so we can enable debug callback
	WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
	#endif
	0,
	};

	rc = wglCreateContextAttribsARB(dc, NULL, attrib);
	if (!rc)
	{
	FatalError("Cannot create modern OpenGL context! OpenGL version 4.5 not supported?");
	}

	BOOL ok = wglMakeCurrent(dc, rc);
	Assert(ok && "Failed to make current OpenGL context");

	// load OpenGL functions
	#define X(type, name) name = (type)wglGetProcAddress(#name); Assert(name);
	GL_FUNCTIONS(X)
	#undef X

	#ifndef NDEBUG
	// enable debug callback
	glDebugMessageCallback(&DebugCallback, NULL);
	glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
	#endif
	}

	windows[wi] = window;
	dcs[wi] = dc;
	}

	struct Vertex
	{
	float position[2];
	float uv[2];
	float color[3];
	};

	// vertex buffer containing triangle vertices
	GLuint vbo;
	{
	struct Vertex data[] =
	{
	{ { -0.00f, +0.75f }, { 25.0f, 50.0f }, { 1, 0, 0 } },
	{ { +0.75f, -0.50f }, { 0.0f, 0.0f }, { 0, 1, 0 } },
	{ { -0.75f, -0.50f }, { 50.0f, 0.0f }, { 0, 0, 1 } },
	};
	glCreateBuffers(1, &vbo);
	glNamedBufferStorage(vbo, sizeof(data), data, 0);
	}

	// vertex input
	GLuint vao;
	{
	glCreateVertexArrays(1, &vao);

	GLint vbuf_index = 0;
	glVertexArrayVertexBuffer(vao, vbuf_index, vbo, 0, sizeof(struct Vertex));

	GLint a_pos = 0;
	glVertexArrayAttribFormat(vao, a_pos, 2, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, position));
	glVertexArrayAttribBinding(vao, a_pos, vbuf_index);
	glEnableVertexArrayAttrib(vao, a_pos);

	GLint a_uv = 1;
	glVertexArrayAttribFormat(vao, a_uv, 2, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, uv));
	glVertexArrayAttribBinding(vao, a_uv, vbuf_index);
	glEnableVertexArrayAttrib(vao, a_uv);

	GLint a_color = 2;
	glVertexArrayAttribFormat(vao, a_color, 3, GL_FLOAT, GL_FALSE, offsetof(struct Vertex, color));
	glVertexArrayAttribBinding(vao, a_color, vbuf_index);
	glEnableVertexArrayAttrib(vao, a_color);
	}

	// checkerboard texture, with 50% transparency on black colors
	GLuint texture;
	{
	unsigned int pixels[] =
	{
	0x80000000, 0xffffffff,
	0xffffffff, 0x80000000,
	};

	glCreateTextures(GL_TEXTURE_2D, 1, &texture);
	glTextureParameteri(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTextureParameteri(texture, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTextureParameteri(texture, GL_TEXTURE_WRAP_T, GL_REPEAT);

	GLsizei width = 2;
	GLsizei height = 2;
	glTextureStorage2D(texture, 1, GL_RGBA8, width, height);
	glTextureSubImage2D(texture, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
	}

	// fragment & vertex shaders for drawing triangle
	GLuint pipeline, vshader, fshader;
	{
	const char* glsl_vshader =
	"#version 450 core \n"
	"#line " STR(__LINE__) " \n\n" // actual line number in this file for nicer error messages
	" \n"
	"layout (location=0) in vec2 a_pos; \n" // position attribute index 0
	"layout (location=1) in vec2 a_uv; \n" // uv attribute index 1
	"layout (location=2) in vec3 a_color; \n" // color attribute index 2
	" \n"
	"layout (location=0) \n" // (from ARB_explicit_uniform_location)
	"uniform mat2 u_matrix; \n" // matrix uniform location 0
	" \n"
	"out gl_PerVertex { vec4 gl_Position; }; \n" // required because of ARB_separate_shader_objects
	"out vec2 uv; \n"
	"out vec4 color; \n"
	" \n"
	"void main() \n"
	"{ \n"
	" vec2 pos = u_matrix * a_pos; \n"
	" gl_Position = vec4(pos, 0, 1); \n"
	" uv = a_uv; \n"
	" color = vec4(a_color, 1); \n"
	"} \n"
	;

	const char* glsl_fshader =
	"#version 450 core \n"
	"#line " STR(__LINE__) " \n\n" // actual line number in this file for nicer error messages
	" \n"
	"in vec2 uv; \n"
	"in vec4 color; \n"
	" \n"
	"layout (binding=0) \n" // (from ARB_shading_language_420pack)
	"uniform sampler2D s_texture; \n" // texture unit binding 0
	" \n"
	"layout (location=0) \n"
	"out vec4 o_color; \n" // output fragment data location 0
	" \n"
	"void main() \n"
	"{ \n"
	" o_color = color * texture(s_texture, uv); \n"
	"} \n"
	;

	vshader = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vshader);
	fshader = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fshader);

	GLint linked;
	glGetProgramiv(vshader, GL_LINK_STATUS, &linked);
	if (!linked)
	{
	char message[1024];
	glGetProgramInfoLog(vshader, sizeof(message), NULL, message);
	OutputDebugStringA(message);
	Assert(!"Failed to create vertex shader!");
	}

	glGetProgramiv(fshader, GL_LINK_STATUS, &linked);
	if (!linked)
	{
	char message[1024];
	glGetProgramInfoLog(fshader, sizeof(message), NULL, message);
	OutputDebugStringA(message);
	Assert(!"Failed to create fragment shader!");
	}

	glGenProgramPipelines(1, &pipeline);
	glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, vshader);
	glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, fshader);
	}

	// setup global GL state
	{
	// enable alpha blending
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	// disble depth testing
	glDisable(GL_DEPTH_TEST);

	// disable culling
	glDisable(GL_CULL_FACE);
	}

	// set to FALSE to disable vsync
	BOOL vsync = TRUE;
	wglSwapIntervalEXT(vsync ? 1 : 0);

	// show all windows once all OpenGL state is set up
	for (int wi=0; wi<WINDOW_COUNT; wi++)
	{
	ShowWindow(windows[wi], SW_SHOWDEFAULT);
	}

	LARGE_INTEGER freq, c1;
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&c1);

	float angles[WINDOW_COUNT] = { 0 };

	for (;;)
	{
	// process all incoming Windows messages
	MSG msg;
	if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
	{
	if (msg.message == WM_QUIT)
	{
	break;
	}
	TranslateMessage(&msg);
	DispatchMessageW(&msg);
	continue;
	}

	LARGE_INTEGER c2;
	QueryPerformanceCounter(&c2);
	float delta = (float)((double)(c2.QuadPart - c1.QuadPart) / freq.QuadPart);
	c1 = c2;

	// we'll be rendering same thing to all windows
	for (int wi=0; wi<WINDOW_COUNT; wi++)
	{
	HWND window = windows[wi];
	HDC dc = dcs[wi];

	// activate OpenGL context for device context where we'll be drawing
	BOOL ok = wglMakeCurrent(dc, rc);
	Assert(ok && "Failed to make current OpenGL context");

	// get current window client area size
	RECT rect;
	GetClientRect(window, &rect);
	width = rect.right - rect.left;
	height = rect.bottom - rect.top;

	// render only if window size is non-zero
	if (width != 0 && height != 0)
	{
	// setup output size covering all client area of window
	glViewport(0, 0, width, height);

	// clear screen
	glClearColor(0.392f, 0.584f, 0.929f, 1.f);
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT \| GL_STENCIL_BUFFER_BIT);

	// setup rotation matrix in uniform
	{
	// different windows will have triangle rotated in different speed
	angles[wi] += delta * 2.0f * (float)M_PI / (10.f + 5.f * wi);
	angles[wi] = fmodf(angles[wi], 2.0f * (float)M_PI);
	float angle = angles[wi];

	float aspect = (float)height / width;
	float matrix[] =
	{
	cosf(angle) * aspect, -sinf(angle),
	sinf(angle) * aspect, cosf(angle),
	};

	GLint u_matrix = 0;
	glProgramUniformMatrix2fv(vshader, u_matrix, 1, GL_FALSE, matrix);
	}

	// activate shaders for next draw call
	glBindProgramPipeline(pipeline);

	// provide vertex input
	glBindVertexArray(vao);

	// bind texture to texture unit
	GLint s_texture = 0; // texture unit that sampler2D will use in GLSL code
	glBindTextureUnit(s_texture, texture);

	// draw 3 vertices as triangle
	glDrawArrays(GL_TRIANGLES, 0, 3);

	// flush all pending OpenGL commands, as we'll be switching to different window
	glFlush();
	}
	else
	{
	// no need to render, window is minimized
	}
	}

	// when all OpenGL commands are submitted, we swap buffers for all windows
	for (int wi=0; wi<WINDOW_COUNT; wi++)
	{
	if (!SwapBuffers(dcs[wi]))
	{
	FatalError("Failed to swap OpenGL buffers!");
	}
	}
	}
	}