git.cworth.org Git - apitrace/blob - glws_wgl.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 Jose Fonseca
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26 #include "glimports.hpp"
  27 #include "glws.hpp"
  28
  29
  30 namespace glws {
  31
  32
  33 static LRESULT CALLBACK
  34 WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  35 {
  36     MINMAXINFO *pMMI;
  37     switch (uMsg) {
  38     case WM_GETMINMAXINFO:
  39         // Allow to create a window bigger than the desktop
  40         pMMI = (MINMAXINFO *)lParam;
  41         pMMI->ptMaxSize.x = 60000;
  42         pMMI->ptMaxSize.y = 60000;
  43         pMMI->ptMaxTrackSize.x = 60000;
  44         pMMI->ptMaxTrackSize.y = 60000;
  45         break;
  46     default:
  47         break;
  48     }
  49
  50     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  51 }
  52
  53
  54 class WglDrawable : public Drawable
  55 {
  56 public:
  57     DWORD dwExStyle;
  58     DWORD dwStyle;
  59     HWND hWnd;
  60     HDC hDC;
  61     PIXELFORMATDESCRIPTOR pfd;
  62     int iPixelFormat;
  63
  64     WglDrawable(const Visual *vis, int width, int height) :
  65         Drawable(vis, width, height)
  66     {
  67         static bool first = TRUE;
  68         RECT rect;
  69
  70         if (first) {
  71             WNDCLASS wc;
  72             memset(&wc, 0, sizeof wc);
  73             wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
  74             wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  75             wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  76             wc.lpfnWndProc = WndProc;
  77             wc.lpszClassName = "glretrace";
  78             wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  79             RegisterClass(&wc);
  80             first = FALSE;
  81         }
  82
  83         dwExStyle = 0;
  84         dwStyle = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW;
  85
  86         int x = 0, y = 0;
  87
  88         rect.left = x;
  89         rect.top = y;
  90         rect.right = rect.left + width;
  91         rect.bottom = rect.top + height;
  92
  93         AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
  94
  95         hWnd = CreateWindowEx(dwExStyle,
  96                               "glretrace", /* wc.lpszClassName */
  97                               NULL,
  98                               dwStyle,
  99                               0, /* x */
 100                               0, /* y */
 101                               rect.right - rect.left, /* width */
 102                               rect.bottom - rect.top, /* height */
 103                               NULL,
 104                               NULL,
 105                               NULL,
 106                               NULL);
 107         hDC = GetDC(hWnd);
 108
 109         memset(&pfd, 0, sizeof pfd);
 110         pfd.cColorBits = 4;
 111         pfd.cRedBits = 1;
 112         pfd.cGreenBits = 1;
 113         pfd.cBlueBits = 1;
 114         pfd.cAlphaBits = 1;
 115         pfd.cDepthBits = 1;
 116         pfd.cStencilBits = 1;
 117         pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
 118         pfd.iLayerType = PFD_MAIN_PLANE;
 119         pfd.iPixelType = PFD_TYPE_RGBA;
 120         pfd.nSize = sizeof(pfd);
 121         pfd.nVersion = 1;
 122
 123         if (visual->doubleBuffer) {
 124            pfd.dwFlags |= PFD_DOUBLEBUFFER;
 125         }
 126
 127         iPixelFormat = ChoosePixelFormat(hDC, &pfd);
 128
 129         SetPixelFormat(hDC, iPixelFormat, &pfd);
 130     }
 131
 132     ~WglDrawable() {
 133         ReleaseDC(hWnd, hDC);
 134         DestroyWindow(hWnd);
 135     }
 136
 137     void
 138     resize(int w, int h) {
 139         if (w == width && h == height) {
 140             return;
 141         }
 142
 143         RECT rClient, rWindow;
 144         GetClientRect(hWnd, &rClient);
 145         GetWindowRect(hWnd, &rWindow);
 146         w += (rWindow.right  - rWindow.left) - rClient.right;
 147         h += (rWindow.bottom - rWindow.top)  - rClient.bottom;
 148         SetWindowPos(hWnd, NULL, rWindow.left, rWindow.top, w, h, SWP_NOMOVE);
 149
 150         Drawable::resize(w, h);
 151     }
 152
 153     void show(void) {
 154         if (visible) {
 155             return;
 156         }
 157
 158         ShowWindow(hWnd, SW_SHOW);
 159
 160         Drawable::show();
 161     }
 162
 163     void swapBuffers(void) {
 164         SwapBuffers(hDC);
 165     }
 166 };
 167
 168
 169 class WglContext : public Context
 170 {
 171 public:
 172     HGLRC hglrc;
 173     WglContext *shareContext;
 174
 175     WglContext(const Visual *vis, WglContext *share) :
 176         Context(vis),
 177         hglrc(0),
 178         shareContext(share)
 179     {}
 180
 181     ~WglContext() {
 182         if (hglrc) {
 183             wglDeleteContext(hglrc);
 184         }
 185     }
 186 };
 187
 188
 189 void
 190 init(void) {
 191 }
 192
 193 void
 194 cleanup(void) {
 195 }
 196
 197 Visual *
 198 createVisual(bool doubleBuffer) {
 199     Visual *visual = new Visual();
 200
 201     visual->doubleBuffer = doubleBuffer;
 202
 203     return visual;
 204 }
 205
 206 Drawable *
 207 createDrawable(const Visual *visual, int width, int height)
 208 {
 209     return new WglDrawable(visual, width, height);
 210 }
 211
 212 Context *
 213 createContext(const Visual *visual, Context *shareContext, Profile profile)
 214 {
 215     if (profile != PROFILE_COMPAT) {
 216         return NULL;
 217     }
 218
 219     return new WglContext(visual, dynamic_cast<WglContext *>(shareContext));
 220 }
 221
 222 bool
 223 makeCurrent(Drawable *drawable, Context *context)
 224 {
 225     if (!drawable || !context) {
 226         return wglMakeCurrent(NULL, NULL);
 227     } else {
 228         WglDrawable *wglDrawable = dynamic_cast<WglDrawable *>(drawable);
 229         WglContext *wglContext = dynamic_cast<WglContext *>(context);
 230
 231         if (!wglContext->hglrc) {
 232             wglContext->hglrc = wglCreateContext(wglDrawable->hDC);
 233             if (!wglContext->hglrc) {
 234                 return false;
 235             }
 236             if (wglContext->shareContext) {
 237                 wglShareLists(wglContext->shareContext->hglrc,
 238                               wglContext->hglrc);
 239             }
 240         }
 241
 242         return wglMakeCurrent(wglDrawable->hDC, wglContext->hglrc);
 243     }
 244 }
 245
 246 bool
 247 processEvents(void) {
 248     // TODO
 249     return true;
 250 }
 251
 252
 253 } /* namespace glws */