[gtk+/master.fcw: 132/648] Add GL Area Support for Windows (WIP ii)
- From: Chun-wei Fan <fanchunwei src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/master.fcw: 132/648] Add GL Area Support for Windows (WIP ii)
- Date: Wed, 4 Feb 2015 05:05:43 +0000 (UTC)
commit 502ff23b0ec7a8d4c331b77944bca2636005a306
Author: Chun-wei Fan <fanchunwei src gnome org>
Date: Tue Dec 2 15:49:47 2014 +0800
Add GL Area Support for Windows (WIP ii)
This is most probably not ready to go into master, but again shows the
progress of the work of adding GL Area support into the Windows GDK
backend.
Current State:
-Is able to create GL 3.2+ contexts, as well as legacy GL contexts.
-Is able to switch GL contexts
-Remaining Issues:
--The GTK+ GUI widgets do not appear, but the controls work.
--Software fallback for gdk_gl_texture_from_surface() is used, as it is
not feasible to use CreateDIBSection() as the OpenGL commands require
more than OpenGL 1.1 (the GL implementation that are created against the
bitmap acquired by CreateDIBSection()), and creating pBuffers are not
feasible due to the performance deficits.
gdk/win32/Makefile.am | 5 +
gdk/win32/gdkdisplay-win32.c | 37 ++-
gdk/win32/gdkdisplay-win32.h | 55 +++++
gdk/win32/gdkglcontext-win32.c | 510 ++++++++++++++++++++++++++++++++++++++++
gdk/win32/gdkglcontext-win32.h | 85 +++++++
gdk/win32/gdkwin32.h | 1 +
gdk/win32/gdkwin32glcontext.h | 49 ++++
gdk/win32/gdkwindow-win32.c | 25 ++-
8 files changed, 749 insertions(+), 18 deletions(-)
---
diff --git a/gdk/win32/Makefile.am b/gdk/win32/Makefile.am
index 640a215..9366867 100644
--- a/gdk/win32/Makefile.am
+++ b/gdk/win32/Makefile.am
@@ -37,10 +37,13 @@ libgdk_win32_la_SOURCES = \
gdkdevice-wintab.c \
gdkdevice-wintab.h \
gdkdisplay-win32.c \
+ gdkdisplay-win32.h \
gdkdisplaymanager-win32.c \
gdkdnd-win32.c \
gdkevents-win32.c \
gdkgeometry-win32.c \
+ gdkglcontext-win32.c \
+ gdkglcontext-win32.h \
gdkglobals-win32.c \
gdkinput.c \
gdkkeys-win32.c \
@@ -55,6 +58,7 @@ libgdk_win32_la_SOURCES = \
gdkwin32display.h \
gdkwin32displaymanager.h \
gdkwin32dnd.h \
+ gdkwin32glcontext.h \
gdkwin32.h \
gdkwin32id.c \
gdkwin32keys.h \
@@ -74,6 +78,7 @@ libgdkwin32include_HEADERS = \
gdkwin32display.h \
gdkwin32displaymanager.h\
gdkwin32dnd.h \
+ gdkwin32glcontext.h \
gdkwin32keys.h \
gdkwin32misc.h \
gdkwin32screen.h \
diff --git a/gdk/win32/gdkdisplay-win32.c b/gdk/win32/gdkdisplay-win32.c
index 97d0e3e..cc6fb67 100644
--- a/gdk/win32/gdkdisplay-win32.c
+++ b/gdk/win32/gdkdisplay-win32.c
@@ -19,7 +19,8 @@
#include "config.h"
#include "gdk.h"
#include "gdkprivate-win32.h"
-#include "gdkdisplayprivate.h"
+#include "gdkdisplay-win32.h"
+#include "gdkglcontext-win32.h"
#include "gdkwin32display.h"
#include "gdkwin32screen.h"
#include "gdkwin32window.h"
@@ -216,16 +217,6 @@ _gdk_win32_display_open (const gchar *display_name)
return _gdk_display;
}
-struct _GdkWin32Display
-{
- GdkDisplay display;
-};
-
-struct _GdkWin32DisplayClass
-{
- GdkDisplayClass display_class;
-};
-
G_DEFINE_TYPE (GdkWin32Display, gdk_win32_display, GDK_TYPE_DISPLAY)
static const gchar *
@@ -571,6 +562,28 @@ gdk_win32_display_sync (GdkDisplay * display)
static void
gdk_win32_display_dispose (GObject *object)
{
+ GdkDisplay *display = GDK_DISPLAY (object);
+ GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+
+ if (display_win32->dummy_hglrc != NULL)
+ {
+ wglDeleteContext (display_win32->dummy_hglrc);
+ display_win32->dummy_hglrc = NULL;
+ }
+ if (display_win32->dummy_hdc != NULL)
+ {
+ ReleaseDC (display_win32->dummy_hwnd, display_win32->dummy_hdc);
+ display_win32->dummy_hdc = NULL;
+ }
+ if (display_win32->is_foreign_window && display_win32->dummy_hwnd != NULL)
+ {
+ DestroyWindow (display_win32->dummy_hwnd);
+ display_win32->dummy_hwnd = NULL;
+ }
+ if (display_win32->dummy_atom_wc != 0)
+ UnregisterClass (MAKEINTATOM (display_win32->dummy_atom_wc), GetModuleHandle (NULL));
+
+ G_OBJECT_CLASS (gdk_win32_display_parent_class)->dispose (object);
}
static void
@@ -581,6 +594,7 @@ gdk_win32_display_finalize (GObject *object)
static void
gdk_win32_display_init(GdkWin32Display *display)
{
+ display->pixel_format = 0;
}
static void
@@ -664,6 +678,7 @@ gdk_win32_display_class_init (GdkWin32DisplayClass *klass)
display_class->convert_selection = _gdk_win32_display_convert_selection;
display_class->text_property_to_utf8_list = _gdk_win32_display_text_property_to_utf8_list;
display_class->utf8_to_string_target = _gdk_win32_display_utf8_to_string_target;
+ display_class->make_gl_context_current = _gdk_win32_display_make_gl_context_current;
_gdk_win32_windowing_init ();
}
diff --git a/gdk/win32/gdkdisplay-win32.h b/gdk/win32/gdkdisplay-win32.h
new file mode 100644
index 0000000..c55cd18
--- /dev/null
+++ b/gdk/win32/gdkdisplay-win32.h
@@ -0,0 +1,55 @@
+/*
+ * gdkdisplay-win32.h
+ *
+ * Copyright 2014 Chun-wei Fan <fanc999 yahoo com tw>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "gdkdisplayprivate.h"
+
+#ifndef __GDK_DISPLAY__WIN32_H__
+#define __GDK_DISPLAY__WIN32_H__
+
+struct _GdkWin32Display
+{
+ GdkDisplay display;
+
+ /* WGL/OpenGL Items */
+ guint have_wgl : 1;
+ gint gl_version;
+ HDC gl_hdc;
+ HWND gl_hwnd;
+ guint pixel_format;
+
+ /* dummy items for use */
+ HWND dummy_hwnd;
+ HDC dummy_hdc;
+ HGLRC dummy_hglrc;
+ ATOM dummy_atom_wc;
+ gboolean is_foreign_window;
+
+ gint hasWglARBCreateContext : 1;
+ gint hasWglARBPbuffer : 1;
+ gint hasWglARBRenderTexture : 1;
+ gint hasWglEXTSwapControl : 1;
+ gint hasWglOMLSyncControl : 1;
+};
+
+struct _GdkWin32DisplayClass
+{
+ GdkDisplayClass display_class;
+};
+
+#endif /* __GDK_DISPLAY__WIN32_H__ */
diff --git a/gdk/win32/gdkglcontext-win32.c b/gdk/win32/gdkglcontext-win32.c
new file mode 100644
index 0000000..1ffb11c
--- /dev/null
+++ b/gdk/win32/gdkglcontext-win32.c
@@ -0,0 +1,510 @@
+/* GDK - The GIMP Drawing Kit
+ *
+ * gdkglcontext-win32.c: Win32 specific OpenGL wrappers
+ *
+ * Copyright © 2014 Emmanuele Bassi
+ * Copyright © 2014 Alexander Larsson
+ * Copyright © 2014 Chun-wei Fan
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gdkprivate-win32.h"
+#include "gdkwindow-win32.h"
+#include "gdkglcontext-win32.h"
+#include "gdkdisplay-win32.h"
+
+#include "gdkwin32display.h"
+#include "gdkwin32glcontext.h"
+#include "gdkwin32misc.h"
+#include "gdkwin32screen.h"
+#include "gdkwin32window.h"
+
+#include "gdkglcontext.h"
+#include "gdkinternals.h"
+#include "gdkintl.h"
+
+#include <epoxy/wgl.h>
+
+G_DEFINE_TYPE (GdkWin32GLContext, gdk_win32_gl_context, GDK_TYPE_GL_CONTEXT)
+
+static void
+gdk_win32_gl_context_dispose (GObject *gobject)
+{
+ GdkGLContext *context = GDK_GL_CONTEXT (gobject);
+ GdkWin32GLContext *context_win32 = GDK_WIN32_GL_CONTEXT (gobject);
+ GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (gdk_gl_context_get_display (context));
+
+ if (context_win32->hglrc != NULL)
+ {
+
+ if (wglGetCurrentContext () == context_win32->hglrc)
+ wglMakeCurrent (NULL, NULL);
+
+ GDK_NOTE (OPENGL, g_print ("Destroying WGL context\n"));
+
+ wglDeleteContext (context_win32->hglrc);
+ context_win32->hglrc = NULL;
+
+ ReleaseDC (display_win32->gl_hwnd, display_win32->gl_hdc);
+ }
+
+ G_OBJECT_CLASS (gdk_win32_gl_context_parent_class)->dispose (gobject);
+}
+
+static void
+gdk_win32_gl_context_class_init (GdkWin32GLContextClass *klass)
+{
+ GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ context_class->end_frame = _gdk_win32_gl_context_end_frame;
+
+ gobject_class->dispose = gdk_win32_gl_context_dispose;
+}
+
+void
+_gdk_win32_gl_context_end_frame (GdkGLContext *context,
+ cairo_region_t *painted,
+ cairo_region_t *damage)
+{
+ GdkWin32GLContext *context_win32 = GDK_WIN32_GL_CONTEXT (context);
+ GdkWindow *window = gdk_gl_context_get_window (context);
+ GdkWin32Display *display = (GDK_WIN32_DISPLAY (gdk_gl_context_get_display (context)));
+ gboolean can_wait = display->hasWglOMLSyncControl;
+
+ gdk_gl_context_make_current (context);
+
+ if (can_wait)
+ {
+ gint64 ust, msc, sbc;
+
+ wglGetSyncValuesOML (context_win32->gl_hdc, &ust, &msc, &sbc);
+ wglWaitForMscOML (context_win32->gl_hdc,
+ 0, 2, (msc + 1) % 2,
+ &ust, &msc, &sbc);
+ }
+
+ SwapBuffers (context_win32->gl_hdc);
+}
+
+void
+_gdk_win32_window_invalidate_for_new_frame (GdkWindow *window,
+ cairo_region_t *update_area)
+{
+ cairo_rectangle_int_t window_rect;
+ unsigned int buffer_age;
+ gboolean invalidate_all;
+ GdkWin32GLContext *context_win32;
+
+ /* Minimal update is ok if we're not drawing with gl */
+ if (window->gl_paint_context == NULL)
+ return;
+
+ context_win32 = GDK_WIN32_GL_CONTEXT (window->gl_paint_context);
+
+ window_rect.x = 0;
+ window_rect.y = 0;
+ window_rect.width = gdk_window_get_width (window);
+ window_rect.height = gdk_window_get_height (window);
+
+ /* If nothing else is known, repaint everything so that the back
+ buffer is fully up-to-date for the swapbuffer */
+ cairo_region_union_rectangle (update_area, &window_rect);
+}
+
+static void _get_dummy_window_hwnd (GdkWin32Display *display)
+{
+ WNDCLASSEX dummy_wc;
+ HWND dummy_hwnd;
+ /* create dummy GL window and get GL function pointers */
+ memset (&dummy_wc, 0, sizeof (WNDCLASSEX));
+
+ dummy_wc.cbSize = sizeof( WNDCLASSEX );
+ dummy_wc.style = CS_OWNDC;
+ dummy_wc.lpfnWndProc = (WNDPROC) DefWindowProc;
+ dummy_wc.cbClsExtra = 0;
+ dummy_wc.cbWndExtra = 0;
+ dummy_wc.hInstance = GetModuleHandle( NULL );
+ dummy_wc.hIcon = 0;
+ dummy_wc.hCursor = NULL;
+ dummy_wc.hbrBackground = 0;
+ dummy_wc.lpszMenuName = 0;
+ dummy_wc.lpszClassName = "dummy";
+ dummy_wc.hIconSm = 0;
+
+ display->dummy_atom_wc = RegisterClassEx (&dummy_wc);
+
+ display->dummy_hwnd =
+ CreateWindowEx (WS_EX_APPWINDOW,
+ MAKEINTATOM (display->dummy_atom_wc),
+ "",
+ WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+ 0,
+ 0,
+ 0,
+ 0,
+ NULL,
+ NULL,
+ GetModuleHandle (NULL),
+ NULL);
+}
+
+static void
+gdk_win32_gl_context_init (GdkWin32GLContext *self)
+{
+}
+
+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 gint
+get_wgl_pfd (HDC hdc, PIXELFORMATDESCRIPTOR *pfd)
+{
+ PIXELFORMATDESCRIPTOR best_pfd;
+ gint configs;
+ gint i;
+ gint best_pf = 0;
+
+ configs = DescribePixelFormat (hdc, 0, sizeof (best_pfd), NULL);
+ for (i = 1; i <= configs; i++)
+ {
+ gint config;
+
+ memset (pfd, 0, sizeof (best_pfd));
+ config = DescribePixelFormat (hdc, i, sizeof (best_pfd), pfd);
+
+ if (config != 0)
+ {
+ if (((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;
+ }
+ }
+ }
+
+ return best_pf;
+}
+
+gboolean
+gdk_win32_display_init_gl (GdkDisplay *display)
+{
+ GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+ gint glMajMinVersion;
+ GdkWindowImplWin32 *impl;
+
+ gboolean set_pixel_format_result = FALSE;
+ gint best_idx = 0;
+
+ PIXELFORMATDESCRIPTOR pfd;
+
+ if (display_win32->have_wgl)
+ return TRUE;
+
+ /* acquire and later cache dummy Window (HWND & HDC) and
+ dummy GL Context, it is used to query functions
+ and used for many other stuff as well */
+ _get_dummy_window_hwnd (display_win32);
+
+ display_win32->dummy_hdc = GetDC (display_win32->dummy_hwnd);
+
+ best_idx = get_wgl_pfd (display_win32->dummy_hdc, &pfd);
+
+ if (best_idx != 0)
+ set_pixel_format_result = SetPixelFormat (display_win32->dummy_hdc,
+ best_idx,
+ &pfd);
+
+ if (best_idx == 0 || !set_pixel_format_result)
+ return FALSE;
+
+ display_win32->dummy_hglrc = wglCreateContext (display_win32->dummy_hdc);
+
+ if (display_win32->dummy_hglrc == NULL)
+ return FALSE;
+
+ if (!wglMakeCurrent (display_win32->dummy_hdc, display_win32->dummy_hglrc))
+ return FALSE;
+
+ display_win32->pixel_format = best_idx;
+ display_win32->have_wgl = TRUE;
+ display_win32->gl_version = epoxy_gl_version ();
+
+ display_win32->hasWglARBCreateContext =
+ epoxy_has_wgl_extension (display_win32->dummy_hdc, "WGL_ARB_create_context");
+ display_win32->hasWglARBPbuffer =
+ epoxy_has_wgl_extension (display_win32->dummy_hdc, "WGL_ARB_pbuffer");
+ display_win32->hasWglARBRenderTexture =
+ epoxy_has_wgl_extension (display_win32->dummy_hdc, "WGL_ARB_render_texture");
+ display_win32->hasWglEXTSwapControl =
+ epoxy_has_wgl_extension (display_win32->dummy_hdc, "WGL_EXT_swap_control");
+ display_win32->hasWglOMLSyncControl =
+ epoxy_has_wgl_extension (display_win32->dummy_hdc, "WGL_OML_sync_control");
+
+ GDK_NOTE (OPENGL,
+ g_print ("WGL API version %d.%d found\n"
+ " - Vendor: %s\n"
+ " - Checked extensions:\n"
+ "\t* WGL_ARB_create_context: %s\n"
+ "\t* WGL_ARB_pbuffer: %s\n"
+ "\t* WGL_ARB_render_texture: %s\n"
+ "\t* WGL_EXT_swap_control: %s\n"
+ "\t* WGL_OML_sync_control: %s\n",
+ display_win32->gl_version / 10,
+ display_win32->gl_version % 10,
+ glGetString (GL_VENDOR),
+ display_win32->hasWglARBCreateContext ? "yes" : "no",
+ display_win32->hasWglARBPbuffer ? "yes" : "no",
+ display_win32->hasWglARBRenderTexture ? "yes" : "no",
+ display_win32->hasWglEXTSwapControl ? "yes" : "no",
+ display_win32->hasWglOMLSyncControl ? "yes" : "no"));
+
+ return TRUE;
+}
+
+static HGLRC
+_create_legacy_gl_context (HDC hdc, GdkGLContext *share)
+{
+ HGLRC hglrc, hglrc2;
+
+ hglrc = wglCreateContext (hdc);
+
+ if (share != NULL)
+ {
+ hglrc2 = GDK_WIN32_GL_CONTEXT (share)->hglrc;
+ wglShareLists (hglrc2, hglrc);
+ }
+
+ return hglrc;
+}
+
+static HGLRC
+_create_gl3_context (HDC hdc,
+ GdkGLContext *share,
+ GdkWin32Display *display)
+{
+ HGLRC hglrc;
+ GdkWin32GLContext *context_win32;
+
+ gint attribs[] = {
+ WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
+ WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+ WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
+ WGL_CONTEXT_MINOR_VERSION_ARB, 2,
+ 0
+ };
+
+ /* Use the dummy GL Context We had earlier... */
+ if (!wglMakeCurrent (hdc, display->dummy_hglrc))
+ return NULL;
+
+ if (share != NULL)
+ context_win32 = GDK_WIN32_GL_CONTEXT (share);
+
+
+ hglrc = wglCreateContextAttribsARB (hdc,
+ share != NULL ? context_win32->hglrc : NULL,
+ attribs);
+
+ wglMakeCurrent (NULL, NULL);
+
+ return hglrc;
+}
+
+static gboolean
+set_pixformat_for_hdc (HDC hdc, gint *best_idx, GError **error)
+{
+ PIXELFORMATDESCRIPTOR pfd;
+ gboolean set_pixel_format_result = FALSE;
+
+ /* one is only allowed to call SetPixelFormat(), and so ChoosePixelFormat()
+ one single time per window HDC */
+ *best_idx = get_wgl_pfd (hdc, &pfd);
+ if (*best_idx != 0)
+ set_pixel_format_result = SetPixelFormat (hdc, *best_idx, &pfd);
+
+ /* ChoosePixelFormat() or SetPixelFormat() failed, bail out */
+ if (*best_idx == 0 || !set_pixel_format_result)
+ {
+ g_set_error_literal (error, GDK_GL_ERROR,
+ GDK_GL_ERROR_UNSUPPORTED_FORMAT,
+ _("No available configurations for the given pixel format"));
+ }
+ return set_pixel_format_result;
+}
+
+GdkGLContext *
+_gdk_win32_window_create_gl_context (GdkWindow *window,
+ gboolean attached,
+ GdkGLProfile profile,
+ GdkGLContext *share,
+ GError **error)
+{
+ GdkDisplay *display = gdk_window_get_display (window);
+ GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (gdk_window_get_display (window));
+ GdkWin32GLContext *context = NULL;
+ GdkVisual *visual = NULL;
+
+ /* Real GL Context and Window items */
+ HWND hwnd = GDK_WINDOW_HWND (window);
+ HDC hdc = GetDC (hwnd);
+ HGLRC hglrc;
+ gint pixel_format;
+
+ if (!gdk_win32_display_init_gl (display))
+ {
+ g_set_error_literal (error, GDK_GL_ERROR,
+ GDK_GL_ERROR_NOT_AVAILABLE,
+ _("No GL implementation is available"));
+ return NULL;
+ }
+
+ if (profile == GDK_GL_PROFILE_3_2_CORE &&
+ !display_win32->hasWglARBCreateContext)
+ {
+ g_set_error_literal (error, GDK_GL_ERROR,
+ GDK_GL_ERROR_UNSUPPORTED_PROFILE,
+ _("The WGL_ARB_create_context extension "
+ "needed to create 3.2 core profiles is not "
+ "available"));
+ return NULL;
+ }
+
+ if (!set_pixformat_for_hdc (hdc, &pixel_format, error))
+ return NULL;
+
+ if (profile == GDK_GL_PROFILE_3_2_CORE)
+ hglrc = _create_gl3_context (hdc, share, display_win32);
+ else
+ {
+ profile = GDK_GL_PROFILE_LEGACY;
+ hglrc = _create_legacy_gl_context (hdc, share);
+ }
+
+ if (hglrc == NULL)
+ {
+ g_set_error_literal (error, GDK_GL_ERROR,
+ GDK_GL_ERROR_NOT_AVAILABLE,
+ _("Unable to create a GL context"));
+ return NULL;
+ }
+
+ display_win32->gl_hdc = hdc;
+ display_win32->gl_hwnd = hwnd;
+
+ GDK_NOTE (OPENGL,
+ g_print ("Created WGL context[%p], pixel_format=%d\n",
+ hglrc,
+ pixel_format));
+
+ context = g_object_new (GDK_TYPE_WIN32_GL_CONTEXT,
+ "display", display,
+ "window", window,
+ "profile", profile,
+ "shared-context", share,
+ NULL);
+
+ context->hglrc = hglrc;
+ context->is_attached = attached;
+
+ return GDK_GL_CONTEXT (context);
+}
+
+gboolean
+_gdk_win32_display_make_gl_context_current (GdkDisplay *display,
+ GdkGLContext *context)
+{
+ GdkWin32GLContext *context_win32;
+ GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
+
+ if (context == NULL)
+ {
+ wglMakeCurrent(NULL, NULL);
+ return TRUE;
+ }
+
+ context_win32 = GDK_WIN32_GL_CONTEXT (context);
+
+ if (!wglMakeCurrent (display_win32->gl_hdc, context_win32->hglrc))
+ {
+ GDK_NOTE (OPENGL,
+ g_print ("Making WGL context current failed\n"));
+ return FALSE;
+ }
+
+ context_win32->gl_hdc = display_win32->gl_hdc;
+
+ if (display_win32->hasWglEXTSwapControl)
+ if (context_win32->is_attached)
+ wglSwapIntervalEXT (1);
+ else
+ wglSwapIntervalEXT (0);
+
+ return TRUE;
+}
+
+gboolean
+gdk_win32_display_get_wgl_version (GdkDisplay *display,
+ gint *major,
+ gint *minor)
+{
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
+
+ if (!GDK_IS_WIN32_DISPLAY (display))
+ return FALSE;
+
+ if (!gdk_win32_display_init_gl (display))
+ return FALSE;
+
+ if (major != NULL)
+ *major = GDK_WIN32_DISPLAY (display)->gl_version / 10;
+ if (minor != NULL)
+ *minor = GDK_WIN32_DISPLAY (display)->gl_version % 10;
+
+ return TRUE;
+}
diff --git a/gdk/win32/gdkglcontext-win32.h b/gdk/win32/gdkglcontext-win32.h
new file mode 100644
index 0000000..cc207db
--- /dev/null
+++ b/gdk/win32/gdkglcontext-win32.h
@@ -0,0 +1,85 @@
+/* GDK - The GIMP Drawing Kit
+ *
+ * gdkglcontext-win32.h: Private Win32 specific OpenGL wrappers
+ *
+ * Copyright © 2014 Chun-wei Fan
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GDK_WIN32_GL_CONTEXT__
+#define __GDK_WIN32_GL_CONTEXT__
+
+#ifndef _WGL_DON_T_INCLUDE_EPOXY_HEADERS
+#include <epoxy/gl.h>
+#include <epoxy/wgl.h>
+#endif
+
+#include "gdkglcontextprivate.h"
+#include "gdkdisplayprivate.h"
+#include "gdkvisual.h"
+#include "gdkwindow.h"
+#include "gdkinternals.h"
+#include "gdkmain.h"
+
+G_BEGIN_DECLS
+
+struct _GdkWin32GLContext
+{
+ GdkGLContext parent_instance;
+
+ /* Real items */
+ HGLRC hglrc;
+ HDC gl_hdc;
+
+ /* other items */
+ gboolean is_attached;
+};
+
+struct _GdkWin32GLContextClass
+{
+ GdkGLContextClass parent_class;
+};
+
+gboolean
+gdk_win32_display_init_gl (GdkDisplay *display);
+
+GdkGLContext *
+_gdk_win32_window_create_gl_context (GdkWindow *window,
+ gboolean attached,
+ GdkGLProfile profile,
+ GdkGLContext *share,
+ GError **error);
+
+void
+_gdk_win32_window_invalidate_for_new_frame (GdkWindow *window,
+ cairo_region_t *update_area);
+
+void
+_gdk_win32_gl_context_end_frame (GdkGLContext *context,
+ cairo_region_t *painted,
+ cairo_region_t *damage);
+
+gboolean
+_gdk_win32_gl_context_texture_from_surface (GdkGLContext *paint_context,
+ cairo_surface_t *surface,
+ cairo_region_t *region);
+
+gboolean
+_gdk_win32_display_make_gl_context_current (GdkDisplay *display,
+ GdkGLContext *context);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_GL_CONTEXT__ */
diff --git a/gdk/win32/gdkwin32.h b/gdk/win32/gdkwin32.h
index 5256392..4550dc7 100644
--- a/gdk/win32/gdkwin32.h
+++ b/gdk/win32/gdkwin32.h
@@ -35,6 +35,7 @@
#include <gdk/win32/gdkwin32screen.h>
#include <gdk/win32/gdkwin32window.h>
#include <gdk/win32/gdkwin32misc.h>
+#include <gdk/win32/gdkwin32glcontext.h>
#undef __GDKWIN32_H_INSIDE__
diff --git a/gdk/win32/gdkwin32glcontext.h b/gdk/win32/gdkwin32glcontext.h
new file mode 100644
index 0000000..fc6e94c
--- /dev/null
+++ b/gdk/win32/gdkwin32glcontext.h
@@ -0,0 +1,49 @@
+/* GDK - The GIMP Drawing Kit
+ *
+ * gdkglcontext-win32.c: Win32 specific OpenGL wrappers
+ *
+ * Copyright © 2014 Chun-wei Fan
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __GDK_WIN32_GL_CONTEXT_H__
+#define __GDK_WIN32_GL_CONTEXT_H__
+
+#if !defined (__GDKWIN32_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdkwin32.h> can be included directly."
+#endif
+
+#include <gdk/gdk.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_WIN32_GL_CONTEXT (gdk_win32_gl_context_get_type ())
+#define GDK_WIN32_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj),
GDK_TYPE_WIN32_GL_CONTEXT, GdkWin32GLContext))
+#define GDK_WIN32_IS_GL_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WIN32_GL_CONTEXT))
+
+typedef struct _GdkWin32GLContext GdkWin32GLContext;
+typedef struct _GdkWin32GLContextClass GdkWin32GLContextClass;
+
+GDK_AVAILABLE_IN_3_16
+GType gdk_win32_gl_context_get_type (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_3_16
+gboolean gdk_win32_display_get_wgl_version (GdkDisplay *display,
+ gint *major,
+ gint *minor);
+
+G_END_DECLS
+
+#endif /* __GDK_WIN32_GL_CONTEXT_H__ */
diff --git a/gdk/win32/gdkwindow-win32.c b/gdk/win32/gdkwindow-win32.c
index 7b4bd79..bd9e39c 100644
--- a/gdk/win32/gdkwindow-win32.c
+++ b/gdk/win32/gdkwindow-win32.c
@@ -38,6 +38,7 @@
#include "gdkdisplayprivate.h"
#include "gdkvisualprivate.h"
#include "gdkwin32window.h"
+#include "gdkglcontext-win32.h"
#include <cairo-win32.h>
@@ -337,12 +338,14 @@ RegisterGdkClass (GdkWindowType wtype, GdkWindowTypeHint wtype_hint)
{
case GDK_WINDOW_TOPLEVEL:
if (0 == klassTOPLEVEL)
- {
- wcl.lpszClassName = L"gdkWindowToplevel";
-
- ONCE_PER_CLASS ();
- klassTOPLEVEL = RegisterClassExW (&wcl);
- }
+ {
+ wcl.lpszClassName = L"gdkWindowToplevel";
+
+ ONCE_PER_CLASS ();
+ klassTOPLEVEL = RegisterClassExW (&wcl);
+ }
+ /* MSDN: CS_OWNDC is needed for OpenGL contexts */
+ wcl.style |= CS_OWNDC;
klass = klassTOPLEVEL;
break;
@@ -351,6 +354,10 @@ RegisterGdkClass (GdkWindowType wtype, GdkWindowTypeHint wtype_hint)
{
wcl.lpszClassName = L"gdkWindowChild";
+ /* XXX: Find out whether GL Widgets are done for GDK_WINDOW_CHILD
+ * MSDN says CS_PARENTDC should not be used for GL Context
+ * creation
+ */
wcl.style |= CS_PARENTDC; /* MSDN: ... enhances system performance. */
ONCE_PER_CLASS ();
klassCHILD = RegisterClassExW (&wcl);
@@ -524,8 +531,9 @@ _gdk_win32_display_create_window_impl (GdkDisplay *display,
}
else
{
+ /* MSDN: We need WS_CLIPCHILDREN and WS_CLIPSIBLINGS for GL Context Creation */
if (window->window_type == GDK_WINDOW_TOPLEVEL)
- dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
+ dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
else
dwStyle = WS_OVERLAPPED | WS_MINIMIZEBOX | WS_SYSMENU | WS_CAPTION | WS_THICKFRAME |
WS_CLIPCHILDREN;
@@ -3440,6 +3448,9 @@ gdk_window_impl_win32_class_init (GdkWindowImplWin32Class *klass)
impl_class->get_property = _gdk_win32_window_get_property;
impl_class->change_property = _gdk_win32_window_change_property;
impl_class->delete_property = _gdk_win32_window_delete_property;
+
+ impl_class->create_gl_context = _gdk_win32_window_create_gl_context;
+ impl_class->invalidate_for_new_frame = _gdk_win32_window_invalidate_for_new_frame;
}
HGDIOBJ
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
