LADI
/
cogl
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add a WGL winsys 

This adds a full winsys to handle WGL and Win32.
This commit is contained in:
Neil Roberts 2011-05-09 17:48:50 +01:00
parent 14d1303259
commit 6788c80342
10 changed files with 974 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
cogl/Makefile.am
View File

@ -319,6 +319,11 @@ cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-glx-feature-functions.h \
$(srcdir)/winsys/cogl-winsys-glx.c
endif
if SUPPORT_WGL
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-wgl.c \
$(srcdir)/winsys/cogl-winsys-wgl-feature-functions.h
endif
if SUPPORT_EGL_PLATFORM_POWERVR_X11
cogl_sources_c += \
$(srcdir)/winsys/cogl-winsys-egl.c

8
cogl/cogl-framebuffer-private.h
View File

@ -38,6 +38,10 @@
#include <GL/glxext.h>
#endif
#ifdef COGL_HAS_WIN32_SUPPORT
#include <windows.h>
#endif
typedef enum _CoglFramebufferType {
COGL_FRAMEBUFFER_TYPE_ONSCREEN,
COGL_FRAMEBUFFER_TYPE_OFFSCREEN
@ -122,6 +126,10 @@ struct _CoglOnscreen
void *foreign_update_mask_data;
#endif
#ifdef COGL_HAS_WIN32_SUPPORT
HWND foreign_hwnd;
#endif
gboolean swap_throttled;
void *winsys;

29
cogl/cogl-framebuffer.c
View File

@ -1679,6 +1679,35 @@ cogl_onscreen_x11_get_visual_xid (CoglOnscreen *onscreen)
}
#endif /* COGL_HAS_X11_SUPPORT */
#ifdef COGL_HAS_WIN32_SUPPORT
void
cogl_onscreen_win32_set_foreign_window (CoglOnscreen *onscreen,
HWND hwnd)
{
onscreen->foreign_hwnd = hwnd;
}
HWND
cogl_onscreen_win32_get_window (CoglOnscreen *onscreen)
{
if (onscreen->foreign_hwnd)
return onscreen->foreign_hwnd;
else
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
const CoglWinsysVtable *winsys =
_cogl_framebuffer_get_winsys (framebuffer);
/* This should only be called for win32 onscreens */
g_return_val_if_fail (winsys->onscreen_win32_get_window != NULL, 0);
return winsys->onscreen_win32_get_window (onscreen);
}
}
#endif /* COGL_HAS_WIN32_SUPPORT */
unsigned int
cogl_framebuffer_add_swap_buffers_callback (CoglFramebuffer *framebuffer,
CoglSwapBuffersNotify callback,

15
cogl/cogl-framebuffer.h
View File

@ -30,6 +30,9 @@
#include <glib.h>
#ifdef COGL_HAS_WIN32
#include <windows.h>
#endif /* COGL_HAS_WIN32 */
G_BEGIN_DECLS
@ -157,6 +160,18 @@ guint32
cogl_onscreen_x11_get_visual_xid (CoglOnscreen *onscreen);
#endif /* COGL_HAS_X11 */
#ifdef COGL_HAS_WIN32_SUPPORT
#define cogl_onscreen_win32_set_foreign_window \
cogl_onscreen_win32_set_foreign_window_EXP
void
cogl_onscreen_win32_set_foreign_window (CoglOnscreen *onscreen,
HWND hwnd);
#define cogl_onscreen_win32_get_window cogl_onscreen_win32_get_window_EXP
HWND
cogl_onscreen_win32_get_window (CoglOnscreen *onscreen);
#endif /* COGL_HAS_WIN32_SUPPORT */
#define cogl_onscreen_set_swap_throttled cogl_onscreen_set_swap_throttled_EXP
void
cogl_onscreen_set_swap_throttled (CoglOnscreen *onscreen,

8
cogl/cogl-renderer.c
View File

@ -48,6 +48,9 @@ extern const CoglWinsysVtable *_cogl_winsys_glx_get_vtable (void);
#ifdef COGL_HAS_EGL_SUPPORT
extern const CoglWinsysVtable *_cogl_winsys_egl_get_vtable (void);
#endif
#ifdef COGL_HAS_WGL_SUPPORT
extern const CoglWinsysVtable *_cogl_winsys_wgl_get_vtable (void);
#endif
typedef const CoglWinsysVtable *(*CoglWinsysVtableGetter) (void);
@ -57,7 +60,10 @@ static CoglWinsysVtableGetter _cogl_winsys_vtable_getters[] =
_cogl_winsys_glx_get_vtable,
#endif
#ifdef COGL_HAS_EGL_SUPPORT
_cogl_winsys_egl_get_vtable
_cogl_winsys_egl_get_vtable,
#endif
#ifdef COGL_HAS_WGL_SUPPORT
_cogl_winsys_wgl_get_vtable,
#endif
};

3
cogl/cogl.h
View File

@ -88,6 +88,9 @@ typedef struct _CoglFramebuffer CoglFramebuffer;
#ifdef COGL_HAS_XLIB
#include <cogl/cogl-xlib.h>
#endif
#ifdef COGL_HAS_WIN32
#include <cogl/cogl-win32.h>
#endif
/* XXX: This will definitly go away once all the Clutter winsys
* code has been migrated down into Cogl! */
#include <cogl/cogl-clutter.h>

5
cogl/winsys/cogl-winsys-private.h
View File

@ -118,6 +118,11 @@ typedef struct _CoglWinsysVtable
guint32
(*onscreen_x11_get_window_xid) (CoglOnscreen *onscreen);
#ifdef COGL_HAS_WIN32_SUPPORT
HWND
(*onscreen_win32_get_window) (CoglOnscreen *onscreen);
#endif
unsigned int
(*onscreen_add_swap_buffers_callback) (CoglOnscreen *onscreen,
CoglSwapBuffersNotify callback,

38
cogl/winsys/cogl-winsys-wgl-feature-functions.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
/* See cogl-winsys-glx-feature-functions.h for a description of how
this file is used */
COGL_WINSYS_FEATURE_BEGIN (swap_control,
"EXT\0",
"swap_control\0",
0,
0,
COGL_WINSYS_FEATURE_SWAP_THROTTLE)
COGL_WINSYS_FEATURE_FUNCTION (int, wglSwapInterval,
(int interval))
COGL_WINSYS_FEATURE_END ()

838
cogl/winsys/cogl-winsys-wgl.c Normal file
View File

@ -0,0 +1,838 @@
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010,2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <windows.h>
#include "cogl.h"
#include "cogl-winsys-private.h"
#include "cogl-context-private.h"
#include "cogl-framebuffer.h"
#include "cogl-swap-chain-private.h"
#include "cogl-renderer-private.h"
#include "cogl-display-private.h"
#include "cogl-onscreen-template-private.h"
#include "cogl-private.h"
#include "cogl-feature-private.h"
typedef struct _CoglRendererWgl
{
/* Function pointers for GLX specific extensions */
#define COGL_WINSYS_FEATURE_BEGIN(a, b, c, d, e, f)
#define COGL_WINSYS_FEATURE_FUNCTION(ret, name, args) \
ret (APIENTRY * pf_ ## name) args;
#define COGL_WINSYS_FEATURE_END()
#include "cogl-winsys-wgl-feature-functions.h"
#undef COGL_WINSYS_FEATURE_BEGIN
#undef COGL_WINSYS_FEATURE_FUNCTION
#undef COGL_WINSYS_FEATURE_END
} CoglRendererWgl;
typedef struct _CoglDisplayWgl
{
ATOM window_class;
HGLRC wgl_context;
HWND dummy_hwnd;
HDC dummy_dc;
} CoglDisplayWgl;
typedef struct _CoglOnscreenWin32
{
HWND hwnd;
gboolean is_foreign_hwnd;
} CoglOnscreenWin32;
typedef struct _CoglContextWgl
{
HDC current_dc;
} CoglContextWgl;
typedef struct _CoglOnscreenWgl
{
CoglOnscreenWin32 _parent;
HDC client_dc;
gboolean swap_throttled;
} CoglOnscreenWgl;
/* Define a set of arrays containing the functions required from GL
for each winsys feature */
#define COGL_WINSYS_FEATURE_BEGIN(name, namespaces, extension_names, \
feature_flags, feature_flags_private, \
winsys_feature) \
static const CoglFeatureFunction \
cogl_wgl_feature_ ## name ## _funcs[] = {
#define COGL_WINSYS_FEATURE_FUNCTION(ret, name, args) \
{ G_STRINGIFY (name), G_STRUCT_OFFSET (CoglRendererWgl, pf_ ## name) },
#define COGL_WINSYS_FEATURE_END() \
{ NULL, 0 }, \
};
#include "cogl-winsys-wgl-feature-functions.h"
/* Define an array of features */
#undef COGL_WINSYS_FEATURE_BEGIN
#define COGL_WINSYS_FEATURE_BEGIN(name, namespaces, extension_names, \
feature_flags, feature_flags_private, \
winsys_feature) \
{ 255, 255, namespaces, extension_names, \
feature_flags, feature_flags_private, \
winsys_feature, \
cogl_wgl_feature_ ## name ## _funcs },
#undef COGL_WINSYS_FEATURE_FUNCTION
#define COGL_WINSYS_FEATURE_FUNCTION(ret, name, args)
#undef COGL_WINSYS_FEATURE_END
#define COGL_WINSYS_FEATURE_END()
static const CoglFeatureData winsys_feature_data[] =
{
#include "cogl-winsys-wgl-feature-functions.h"
};
static CoglFuncPtr
_cogl_winsys_get_proc_address (const char *name)
{
return (CoglFuncPtr) wglGetProcAddress ((LPCSTR) name);
}
static void
_cogl_winsys_renderer_disconnect (CoglRenderer *renderer)
{
g_slice_free (CoglRendererWgl, renderer->winsys);
}
static CoglOnscreen *
find_onscreen_for_hwnd (CoglContext *context, HWND hwnd)
{
CoglDisplayWgl *display_wgl = context->display->winsys;
GList *l;
/* If the hwnd has Cogl's window class then we can lookup the
onscreen pointer directly by reading the extra window data */
if (GetClassLongPtr (hwnd, GCW_ATOM) == display_wgl->window_class)
{
CoglOnscreen *onscreen = (CoglOnscreen *) GetWindowLongPtr (hwnd, 0);
if (onscreen)
return onscreen;
}
for (l = context->framebuffers; l; l = l->next)
{
CoglFramebuffer *framebuffer = l->data;
if (framebuffer->type == COGL_FRAMEBUFFER_TYPE_ONSCREEN)
{
CoglOnscreenWin32 *win32_onscreen =
COGL_ONSCREEN (framebuffer)->winsys;
if (win32_onscreen->hwnd == hwnd)
return COGL_ONSCREEN (framebuffer);
}
}
return NULL;
}
static CoglFilterReturn
win32_event_filter_cb (void *native_event, void *data)
{
MSG *msg = native_event;
CoglContext *context = data;
if (msg->message == WM_SIZE)
{
CoglOnscreen *onscreen =
find_onscreen_for_hwnd (context, msg->hwnd);
if (onscreen)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
/* Ignore size changes resulting from the stage being
minimized - otherwise it will think the window has been
resized to 0,0 */
if (msg->wParam != SIZE_MINIMIZED)
{
WORD new_width = LOWORD (msg->lParam);
WORD new_height = HIWORD (msg->lParam);
_cogl_framebuffer_winsys_update_size (framebuffer,
new_width,
new_height);
}
}
}
return COGL_FILTER_CONTINUE;
}
static gboolean
_cogl_winsys_renderer_connect (CoglRenderer *renderer,
GError **error)
{
renderer->winsys = g_slice_new0 (CoglRendererWgl);
return TRUE;
}
static LRESULT CALLBACK
window_proc (HWND hwnd, UINT umsg,
WPARAM wparam, LPARAM lparam)
{
gboolean message_handled = FALSE;
CoglOnscreen *onscreen;
/* It's not clear what the best thing to do with messages sent to
the window proc is. We want the application to forward on all
messages through Cogl so that it can have a chance to process
them which might mean that that in it's GetMessage loop it could
call cogl_renderer_handle_native_event for every message. However
the message loop would usually call DispatchMessage as well which
mean this window proc would be invoked and Cogl would see the
message twice. However we can't just ignore messages in the
window proc because some messages are sent directly from windows
without going through the message queue. This function therefore
just forwards on all messages directly. This means that the
application is not expected to forward on messages if it has let
Cogl create the window itself because it will already see them
via the window proc. This limits the kinds of messages that Cogl
can handle to ones that are sent to the windows it creates, but I
think that is a reasonable restriction */
/* Convert the message to a MSG struct and pass it through the Cogl
message handling mechanism */
/* This window proc is only called for messages created with Cogl's
window class so we should be able to work out the corresponding
window class by looking in the extra window data. Windows will
send some extra messages before we get a chance to set this value
so we have to ignore these */
onscreen = (CoglOnscreen *) GetWindowLongPtr (hwnd, 0);
if (onscreen != NULL)
{
CoglRenderer *renderer;
DWORD message_pos;
MSG msg;
msg.hwnd = hwnd;
msg.message = umsg;
msg.wParam = wparam;
msg.lParam = lparam;
msg.time = GetMessageTime ();
/* Neither MAKE_POINTS nor GET_[XY]_LPARAM is defined in MinGW
headers so we need to convert to a signed type explicitly */
message_pos = GetMessagePos ();
msg.pt.x = (SHORT) LOWORD (message_pos);
msg.pt.y = (SHORT) HIWORD (message_pos);
renderer = COGL_FRAMEBUFFER (onscreen)->context->display->renderer;
message_handled =
cogl_renderer_handle_native_event (renderer, &msg);
}
if (!message_handled)
return DefWindowProcW (hwnd, umsg, wparam, lparam);
else
return 0;
}
static gboolean
pixel_format_is_better (const PIXELFORMATDESCRIPTOR *pfa,
const PIXELFORMATDESCRIPTOR *pfb)
{
/* Always prefer a format with a stencil buffer */
if (pfa->cStencilBits == 0)
{
if (pfb->cStencilBits > 0)
return TRUE;
}
else if (pfb->cStencilBits == 0)
return FALSE;
/* Prefer a bigger color buffer */
if (pfb->cColorBits > pfa->cColorBits)
return TRUE;
else if (pfb->cColorBits < pfa->cColorBits)
return FALSE;
/* Prefer a bigger depth buffer */
return pfb->cDepthBits > pfa->cDepthBits;
}
static int
choose_pixel_format (HDC dc, PIXELFORMATDESCRIPTOR *pfd)
{
int i, num_formats, best_pf = 0;
PIXELFORMATDESCRIPTOR best_pfd;
num_formats = DescribePixelFormat (dc, 0, sizeof (best_pfd), NULL);
for (i = 1; i <= num_formats; i++)
{
memset (pfd, 0, sizeof (*pfd));
if (DescribePixelFormat (dc, i, sizeof (best_pfd), pfd) &&
/* Check whether this format is useable by Cogl */
((pfd->dwFlags & (PFD_SUPPORT_OPENGL |
PFD_DRAW_TO_WINDOW |
PFD_DOUBLEBUFFER |
PFD_GENERIC_FORMAT)) ==
(PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW)) &&
pfd->iPixelType == PFD_TYPE_RGBA &&
pfd->cColorBits >= 16 && pfd->cColorBits <= 32 &&
pfd->cDepthBits >= 16 && pfd->cDepthBits <= 32 &&
/* Check whether this is a better format than one we've
already found */
(best_pf == 0 || pixel_format_is_better (&best_pfd, pfd)))
{
best_pf = i;
best_pfd = *pfd;
}
}
*pfd = best_pfd;
return best_pf;
}
static gboolean
create_window_class (CoglDisplay *display, GError **error)
{
CoglDisplayWgl *wgl_display = display->winsys;
char *class_name_ascii, *src;
WCHAR *class_name_wchar, *dst;
WNDCLASSW wndclass;
/* We create a window class per display so that we have an
opportunity to clean up the class when the display is
destroyed */
/* Generate a unique name containing the address of the display */
class_name_ascii = g_strdup_printf ("CoglWindow0x%0*" G_GINTPTR_MODIFIER "x",
sizeof (guintptr) * 2,
(guintptr) display);
/* Convert it to WCHARs */
class_name_wchar = g_malloc ((strlen (class_name_ascii) + 1) *
sizeof (WCHAR));
for (src = class_name_ascii, dst = class_name_wchar;
*src;
src++, dst++)
*dst = *src;
*dst = L'\0';
memset (&wndclass, 0, sizeof (wndclass));
wndclass.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = window_proc;
/* We reserve extra space in the window data for a pointer back to
the CoglOnscreen */
wndclass.cbWndExtra = sizeof (LONG_PTR);
wndclass.hInstance = GetModuleHandleW (NULL);
wndclass.hIcon = LoadIconW (NULL, (LPWSTR) IDI_APPLICATION);
wndclass.hCursor = LoadCursorW (NULL, (LPWSTR) IDC_ARROW);
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = class_name_wchar;
wgl_display->window_class = RegisterClassW (&wndclass);
g_free (class_name_wchar);
g_free (class_name_ascii);
if (wgl_display->window_class == 0)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Unable to register window class");
return FALSE;
}
return TRUE;
}
static gboolean
create_context (CoglDisplay *display, GError **error)
{
CoglDisplayWgl *wgl_display = display->winsys;
g_return_val_if_fail (wgl_display->wgl_context == NULL, FALSE);
/* Cogl assumes that there is always a GL context selected; in order
* to make sure that a WGL context exists and is made current, we
* use a small dummy window that never gets shown to which we can
* always fall back if no onscreen is available
*/
if (wgl_display->dummy_hwnd == NULL)
{
wgl_display->dummy_hwnd =
CreateWindowW ((LPWSTR) MAKEINTATOM (wgl_display->window_class),
L".",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
1, 1,
NULL, NULL,
GetModuleHandle (NULL),
NULL);
if (wgl_display->dummy_hwnd == NULL)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Unable to create dummy window");
return FALSE;
}
}
if (wgl_display->dummy_dc == NULL)
{
PIXELFORMATDESCRIPTOR pfd;
int pf;
wgl_display->dummy_dc = GetDC (wgl_display->dummy_hwnd);
pf = choose_pixel_format (wgl_display->dummy_dc, &pfd);
if (pf == 0 || !SetPixelFormat (wgl_display->dummy_dc, pf, &pfd))
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Unable to find suitable GL pixel format");
ReleaseDC (wgl_display->dummy_hwnd, wgl_display->dummy_dc);
wgl_display->dummy_dc = NULL;
return FALSE;
}
}
if (wgl_display->wgl_context == NULL)
{
wgl_display->wgl_context = wglCreateContext (wgl_display->dummy_dc);
if (wgl_display->wgl_context == NULL)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"Unable to create suitable GL context");
return FALSE;
}
}
COGL_NOTE (WINSYS, "Selecting dummy 0x%x for the WGL context",
(unsigned int) wgl_display->dummy_hwnd);
wglMakeCurrent (wgl_display->dummy_dc, wgl_display->wgl_context);
return TRUE;
}
static void
_cogl_winsys_display_destroy (CoglDisplay *display)
{
CoglDisplayWgl *wgl_display = display->winsys;
g_return_if_fail (wgl_display != NULL);
if (wgl_display->wgl_context)
{
wglMakeCurrent (NULL, NULL);
wglDeleteContext (wgl_display->wgl_context);
}
if (wgl_display->dummy_dc)
ReleaseDC (wgl_display->dummy_hwnd, wgl_display->dummy_dc);
if (wgl_display->dummy_hwnd)
DestroyWindow (wgl_display->dummy_hwnd);
if (wgl_display->window_class)
UnregisterClassW ((LPWSTR) MAKEINTATOM (wgl_display->window_class),
GetModuleHandleW (NULL));
g_slice_free (CoglDisplayWgl, display->winsys);
display->winsys = NULL;
}
static gboolean
_cogl_winsys_display_setup (CoglDisplay *display,
GError **error)
{
CoglDisplayWgl *wgl_display;
g_return_val_if_fail (display->winsys == NULL, FALSE);
wgl_display = g_slice_new0 (CoglDisplayWgl);
display->winsys = wgl_display;
if (!create_window_class (display, error))
goto error;
if (!create_context (display, error))
goto error;
return TRUE;
error:
_cogl_winsys_display_destroy (display);
return FALSE;
}
static const char *
get_wgl_extensions_string (HDC dc)
{
const char * (APIENTRY *pf_wglGetExtensionsStringARB) (HDC);
const char * (APIENTRY *pf_wglGetExtensionsStringEXT) (void);
/* According to the docs for these two extensions, you are supposed
to use wglGetProcAddress to detect their availability so
presumably it will return NULL if they are not available */
pf_wglGetExtensionsStringARB =
(void *) wglGetProcAddress ("wglGetExtensionsStringARB");
if (pf_wglGetExtensionsStringARB)
return pf_wglGetExtensionsStringARB (dc);
pf_wglGetExtensionsStringEXT =
(void *) wglGetProcAddress ("wglGetExtensionsStringEXT");
if (pf_wglGetExtensionsStringEXT)
return pf_wglGetExtensionsStringEXT ();
/* The WGL_EXT_swap_control is also advertised as a GL extension as
GL_EXT_SWAP_CONTROL so if the extension to get the list of WGL
extensions isn't supported then we can at least fake it to
support the swap control extension */
if (_cogl_check_extension ("WGL_EXT_swap_control",
(char *) glGetString (GL_EXTENSIONS)))
return "WGL_EXT_swap_control";
return NULL;
}
static void
update_winsys_features (CoglContext *context)
{
CoglDisplayWgl *wgl_display = context->display->winsys;
CoglRendererWgl *wgl_renderer = context->display->renderer->winsys;
const char *wgl_extensions;
int i;
g_return_if_fail (wgl_display->wgl_context);
_cogl_gl_update_features (context);
memset (context->winsys_features, 0, sizeof (context->winsys_features));
context->feature_flags |= COGL_FEATURE_ONSCREEN_MULTIPLE;
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN,
TRUE);
wgl_extensions = get_wgl_extensions_string (wgl_display->dummy_dc);
if (wgl_extensions)
{
COGL_NOTE (WINSYS, " WGL Extensions: %s", wgl_extensions);
for (i = 0; i < G_N_ELEMENTS (winsys_feature_data); i++)
if (_cogl_feature_check ("WGL", winsys_feature_data + i, 0, 0,
wgl_extensions,
wgl_renderer))
{
context->feature_flags |= winsys_feature_data[i].feature_flags;
if (winsys_feature_data[i].winsys_feature)
COGL_FLAGS_SET (context->winsys_features,
winsys_feature_data[i].winsys_feature,
TRUE);
}
}
}
static gboolean
_cogl_winsys_context_init (CoglContext *context, GError **error)
{
CoglContextWgl *wgl_context;
wgl_context = context->winsys = g_new0 (CoglContextWgl, 1);
cogl_renderer_add_native_filter (context->display->renderer,
win32_event_filter_cb,
context);
update_winsys_features (context);
return TRUE;
}
static void
_cogl_winsys_context_deinit (CoglContext *context)
{
cogl_renderer_remove_native_filter (context->display->renderer,
win32_event_filter_cb,
context);
g_free (context->winsys);
}
static gboolean
_cogl_winsys_onscreen_init (CoglOnscreen *onscreen,
GError **error)
{
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglDisplay *display = context->display;
CoglDisplayWgl *wgl_display = display->winsys;
CoglOnscreenWgl *wgl_onscreen;
CoglOnscreenWin32 *win32_onscreen;
PIXELFORMATDESCRIPTOR pfd;
int pf;
HWND hwnd;
g_return_val_if_fail (wgl_display->wgl_context, FALSE);
/* XXX: Note we ignore the user's original width/height when given a
* foreign window. */
if (onscreen->foreign_hwnd)
{
RECT client_rect;
hwnd = onscreen->foreign_hwnd;
GetClientRect (hwnd, &client_rect);
_cogl_framebuffer_winsys_update_size (framebuffer,
client_rect.right,
client_rect.bottom);
}
else
{
int width, height;
width = COGL_FRAMEBUFFER (onscreen)->width;
height = COGL_FRAMEBUFFER (onscreen)->height;
/* The size of the window passed to CreateWindow for some reason
includes the window decorations so we need to compensate for
that */
width += GetSystemMetrics (SM_CXSIZEFRAME) * 2;
height += (GetSystemMetrics (SM_CYSIZEFRAME) * 2 +
GetSystemMetrics (SM_CYCAPTION));
hwnd = CreateWindowW ((LPWSTR) MAKEINTATOM (wgl_display->window_class),
L".",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, /* xpos */
CW_USEDEFAULT, /* ypos */
width,
height,
NULL, /* parent */
NULL, /* menu */
GetModuleHandle (NULL),
NULL /* lparam for the WM_CREATE message */);
if (hwnd == NULL)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Unable to create window");
return FALSE;
}
/* Store a pointer back to the onscreen in the window extra data
so we can refer back to it quickly */
SetWindowLongPtrW (hwnd, 0, (LONG_PTR) onscreen);
}
onscreen->winsys = g_slice_new0 (CoglOnscreenWgl);
win32_onscreen = onscreen->winsys;
wgl_onscreen = onscreen->winsys;
win32_onscreen->hwnd = hwnd;
wgl_onscreen->client_dc = GetDC (hwnd);
/* Use the same pixel format as the dummy DC from the renderer */
pf = GetPixelFormat (wgl_display->dummy_dc);
DescribePixelFormat (wgl_display->dummy_dc, pf, sizeof (pfd), &pfd);
if (!SetPixelFormat (wgl_onscreen->client_dc, pf, &pfd))
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error setting pixel format on the window");
ReleaseDC (hwnd, wgl_onscreen->client_dc);
return FALSE;
}
return TRUE;
}
static void
_cogl_winsys_onscreen_bind (CoglOnscreen *onscreen)
{
CoglContext *context;
CoglContextWgl *wgl_context;
CoglDisplayWgl *wgl_display;
CoglOnscreenWgl *wgl_onscreen;
CoglRendererWgl *wgl_renderer;
/* The glx backend tries to bind the dummy context if onscreen ==
NULL, but this isn't really going to work because before checking
whether onscreen == NULL it reads the pointer to get the
context */
g_return_if_fail (onscreen != NULL);
context = COGL_FRAMEBUFFER (onscreen)->context;
wgl_context = context->winsys;
wgl_display = context->display->winsys;
wgl_onscreen = onscreen->winsys;
wgl_renderer = context->display->renderer->winsys;
if (wgl_context->current_dc == wgl_onscreen->client_dc)
return;
wglMakeCurrent (wgl_onscreen->client_dc, wgl_display->wgl_context);
/* According to the specs for WGL_EXT_swap_control SwapInterval()
* applies to the current window not the context so we apply it here
* to ensure its up-to-date even for new windows.
*/
if (wgl_renderer->pf_wglSwapInterval)
{
if (onscreen->swap_throttled)
wgl_renderer->pf_wglSwapInterval (1);
else
wgl_renderer->pf_wglSwapInterval (0);
}
wgl_context->current_dc = wgl_onscreen->client_dc;
}
static void
_cogl_winsys_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglContextWgl *wgl_context = context->winsys;
CoglOnscreenWin32 *win32_onscreen = onscreen->winsys;
CoglOnscreenWgl *wgl_onscreen = onscreen->winsys;
if (wgl_context->current_dc == wgl_onscreen->client_dc)
_cogl_winsys_onscreen_bind (NULL);
ReleaseDC (win32_onscreen->hwnd, wgl_onscreen->client_dc);
if (!win32_onscreen->is_foreign_hwnd)
{
/* Drop the pointer to the onscreen in the window so that any
further messages won't be processed */
SetWindowLongPtrW (win32_onscreen->hwnd, 0, (LONG_PTR) 0);
DestroyWindow (win32_onscreen->hwnd);
}
}
static void
_cogl_winsys_onscreen_swap_buffers (CoglOnscreen *onscreen)
{
CoglOnscreenWgl *wgl_onscreen = onscreen->winsys;
SwapBuffers (wgl_onscreen->client_dc);
}
static void
_cogl_winsys_onscreen_update_swap_throttled (CoglOnscreen *onscreen)
{
CoglContext *context = COGL_FRAMEBUFFER (onscreen)->context;
CoglContextWgl *wgl_context = context->winsys;
CoglOnscreenWgl *wgl_onscreen = onscreen->winsys;
if (wgl_context->current_dc != wgl_onscreen->client_dc)
return;
/* This will cause it to rebind the context and update the swap interval */
wgl_context->current_dc = NULL;
_cogl_winsys_onscreen_bind (onscreen);
}
static HWND
_cogl_winsys_onscreen_win32_get_window (CoglOnscreen *onscreen)
{
CoglOnscreenWin32 *win32_onscreen = onscreen->winsys;
return win32_onscreen->hwnd;
}
static void
_cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
gboolean visibility)
{
CoglOnscreenWin32 *win32_onscreen = onscreen->winsys;
ShowWindow (win32_onscreen->hwnd, visibility ? SW_SHOW : SW_HIDE);
}
const CoglWinsysVtable *
_cogl_winsys_wgl_get_vtable (void)
{
static gboolean vtable_inited = FALSE;
static CoglWinsysVtable vtable;
/* It would be nice if we could use C99 struct initializers here
like the GLX backend does. However this code is more likely to be
compiled using Visual Studio which (still!) doesn't support them
so we initialize it in code instead */
if (!vtable_inited)
{
memset (&vtable, 0, sizeof (vtable));
vtable.name = "WGL";
vtable.get_proc_address = _cogl_winsys_get_proc_address;
vtable.renderer_connect = _cogl_winsys_renderer_connect;
vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect;
vtable.display_setup = _cogl_winsys_display_setup;
vtable.display_destroy = _cogl_winsys_display_destroy;
vtable.context_init = _cogl_winsys_context_init;
vtable.context_deinit = _cogl_winsys_context_deinit;
vtable.onscreen_init = _cogl_winsys_onscreen_init;
vtable.onscreen_deinit = _cogl_winsys_onscreen_deinit;
vtable.onscreen_bind = _cogl_winsys_onscreen_bind;
vtable.onscreen_swap_buffers = _cogl_winsys_onscreen_swap_buffers;
vtable.onscreen_update_swap_throttled =
_cogl_winsys_onscreen_update_swap_throttled;
vtable.onscreen_set_visibility = _cogl_winsys_onscreen_set_visibility;
vtable.onscreen_win32_get_window = _cogl_winsys_onscreen_win32_get_window;
vtable_inited = TRUE;
}
return &vtable;
}

26
configure.ac
View File

@ -404,6 +404,7 @@ AS_IF([test "x$enable_gl" = "xyes"],
[
COGL_EXTRA_LDFLAGS="$COGL_EXTRA_LDFLAGS -lopengl32 -lgdi32 -lwinmm"
COGL_EXTRA_CFLAGS="$COGL_EXTRA_CFLAGS -D_WIN32_WINNT=0x0500"
ALLOW_WGL=yes
],
[
PKG_CHECK_EXISTS(
@ -446,6 +447,7 @@ AS_IF([test "x$enable_stub_winsys" = "xyes"],
[
GL_WINSYS_APIS="$GL_WINSYS_APIS stub"
ALLOW_GLX=no
ALLOW_WGL=no
])
AM_CONDITIONAL(SUPPORT_STUB, [test "x$enable_stub_winsys" = "xyes"])
@ -481,6 +483,30 @@ AS_IF([test "x$enable_glx" = "xyes"],
])
AM_CONDITIONAL(SUPPORT_GLX, [test "x$SUPPORT_GLX" = "xyes"])
AC_ARG_ENABLE(
[wgl],
[AC_HELP_STRING([--enable-wgl=@<:@no/yes@:>@], [Enable support for WGL @<:@default=auto@:>@])],
[],
[AS_IF([test "x$ALLOW_WGL" = "xyes"], [enable_wgl=yes], [enable_wgl=no])]
)
AS_IF([test "x$enable_wgl" = "xyes"],
[
AS_IF([test "x$enable_stub_winsys" = "xyes"],
[AC_MSG_ERROR([Stub winsys not currently compatible with others])])
AS_IF([test "x$ALLOW_WGL" != "xyes"],
[AC_MSG_ERROR([WGL not supported with $COGL_DRIVER driver])])
SUPPORT_WGL=yes
GL_WINSYS_APIS="$GL_WINSYS_APIS wgl"
AC_DEFINE([COGL_HAS_WGL_SUPPORT], [1], [Cogl supports OpenGL using the WGL API])
COGL_DEFINES_SYMBOLS="$COGL_DEFINES_SYMBOLS COGL_HAS_WIN32_SUPPORT"
AC_DEFINE([COGL_HAS_FULL_WINSYS], [1],
[Cogl can create its own OpenGL context])
])
AM_CONDITIONAL(SUPPORT_WGL, [test "x$SUPPORT_WGL" = "xyes"])
EGL_PLATFORM_COUNT=0