]> git.tdb.fi Git - libs/gui.git/blob - glcontext.cpp
5a13dc4f79e6068089521ed887cb441723203931
[libs/gui.git] / glcontext.cpp
1 #include "glcontext.h"
2 #include <vector>
3 #include <windows.h>
4 #include <GL/gl.h>
5 #include <GL/wglext.h>
6 #include <msp/strings/lexicalcast.h>
7 #include <msp/strings/utils.h>
8 #include "window_private.h"
9
10 using namespace std;
11
12 namespace {
13
14 template<typename T>
15 T get_proc(const char *name)
16 {
17         return reinterpret_cast<T>(reinterpret_cast<void *>(wglGetProcAddress(name)));
18 }
19
20 }
21
22 namespace Msp {
23 namespace Graphics {
24
25 typedef HGLRC ContextHandle;
26
27 struct GLContext::Private
28 {
29         ContextHandle context = nullptr;
30 };
31
32
33 void GLContext::platform_init(const GLOptions &opts)
34 {
35         HDC dc = GetDC(window.get_private().window);
36
37         PIXELFORMATDESCRIPTOR pfd;
38         memset(&pfd, 0, sizeof(pfd));
39
40         pfd.nSize = sizeof(pfd);
41         pfd.nVersion = 1;
42         pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
43         if(opts.doublebuffer)
44                 pfd.dwFlags |= PFD_DOUBLEBUFFER;
45         pfd.iPixelType = PFD_TYPE_RGBA;
46         if(opts.alpha)
47                 pfd.cAlphaBits = 1;
48         pfd.cDepthBits = 1;
49         if(opts.stencil)
50                 pfd.cStencilBits = 1;
51
52         int pf_index = ChoosePixelFormat(dc, &pfd);
53         if(!pf_index)
54                 throw unsupported_gl_mode(opts);
55         SetPixelFormat(dc, pf_index, &pfd);
56
57         priv = new Private;
58         if(opts.forward_compatible || opts.gl_version_major!=GLOptions::DEFAULT_VERSION)
59         {
60                 ContextHandle fake_context = wglCreateContext(dc);
61                 wglMakeCurrent(dc, fake_context);
62
63                 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs = get_proc<PFNWGLCREATECONTEXTATTRIBSARBPROC>("wglCreateContextAttribsARB");
64                 if(!wglCreateContextAttribs)
65                         throw unsupported_gl_mode(opts);
66
67                 unsigned gl_version_major = opts.gl_version_major;
68                 unsigned gl_version_minor = opts.gl_version_minor;
69                 if(opts.gl_version_major==GLOptions::LATEST_VERSION)
70                 {
71                         const char *gl_ver_ptr = reinterpret_cast<const char *>(glGetString(GL_VERSION));
72                         if(!gl_ver_ptr)
73                                 throw unsupported_gl_mode(opts);
74
75                         string gl_ver = gl_ver_ptr;
76                         vector<string> parts = split(gl_ver.substr(0, gl_ver.find(' ')), '.');
77
78                         gl_version_major = lexical_cast<unsigned>(parts[0]);
79                         gl_version_minor = lexical_cast<unsigned>(parts[1]);
80                 }
81
82                 vector<int> ctx_attribs;
83
84                 if(opts.forward_compatible)
85                 {
86                         ctx_attribs.push_back(WGL_CONTEXT_FLAGS_ARB);
87                         ctx_attribs.push_back(WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB);
88                 }
89
90                 if(opts.core_profile)
91                 {
92                         ctx_attribs.push_back(WGL_CONTEXT_PROFILE_MASK_ARB);
93                         ctx_attribs.push_back(WGL_CONTEXT_CORE_PROFILE_BIT_ARB);
94                 }
95
96                 if(opts.gl_version_major)
97                 {
98                         ctx_attribs.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB);
99                         ctx_attribs.push_back(gl_version_major);
100                         ctx_attribs.push_back(WGL_CONTEXT_MINOR_VERSION_ARB);
101                         ctx_attribs.push_back(gl_version_minor);
102                 }
103
104                 ctx_attribs.push_back(0);
105
106                 priv->context = wglCreateContextAttribs(dc, 0, &ctx_attribs[0]);
107                 if(!priv->context)
108                         throw unsupported_gl_mode(opts);
109
110                 wglMakeCurrent(nullptr, nullptr);
111                 wglDeleteContext(fake_context);
112         }
113         else
114                 priv->context = wglCreateContext(dc);
115         wglMakeCurrent(dc, priv->context);
116
117         ReleaseDC(window.get_private().window, dc);
118 }
119
120 GLContext::~GLContext()
121 {
122         wglMakeCurrent(nullptr, nullptr);
123         wglDeleteContext(priv->context);
124
125         delete priv;
126 }
127
128 void GLContext::set_swap_interval(unsigned i)
129 {
130         PFNWGLSWAPINTERVALEXTPROC wglSwapInterval = get_proc<PFNWGLSWAPINTERVALEXTPROC>("wglSwapIntervalEXT");
131         if(!wglSwapInterval)
132                 throw runtime_error("wglSwapIntervalEXT not found");
133         wglSwapInterval(i);
134 }
135
136 void GLContext::swap_buffers()
137 {
138         HDC dc = GetDC(window.get_private().window);
139         SwapBuffers(dc);
140         ReleaseDC(window.get_private().window, dc);
141 }
142
143 void GLContext::window_resized(unsigned, unsigned)
144 { }
145
146 } // namespace Graphics
147 } // namespace Msp