Mirrors_UI_SDK/wxWidgets
1
0
Fork 0
mirror of https://github.com/wxWidgets/wxWidgets.git synced 2026-03-23 18:54:01 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Allow choosing between GLX and EGL during run-time

Browse Source 
The same library binary can now be used to use either GLX or EGL for
wxGLCanvas implementation instead of the choice being done at build time
(by either always using EGL if it is enabled or always using GLX
otherwise).

New wxGLCanvas::PreferGLX() function (available only if wxHAS_GLX is
defined) can be used to request using GLX even if EGL is available,
otherwise EGL is used by default, just as before.

Additionally new "opengl.egl" system option can be used to the same
effect, mostly to allow users to set "wx_opengl_egl" environment
variable to 0 to use GLX if possible, i.e. with X11 and not Wayland.
This commit is contained in:
Vadim Zeitlin
2025-12-10 03:20:54 +01:00
parent 0b574c2363
commit d9df7db130
33 changed files with 1428 additions and 797 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
Makefile.in
View File

@@ -2630,13 +2630,14 @@ COND_PLATFORM_WIN32_1_GTK_PLATFORM_HDR = \
@COND_TOOLKIT_MSW@WEBVIEW_PLATFORM_HDR = \
@COND_TOOLKIT_MSW@ wx/msw/webviewhistoryitem_ie.h wx/msw/webview_ie.h \
@COND_TOOLKIT_MSW@ wx/msw/webview_edge.h
@COND_TOOLKIT_GTK@OPENGL_PLATFORM_HDR = wx/unix/glx11.h \
@COND_TOOLKIT_GTK@ wx/gtk/glcanvas.h wx/unix/glegl.h
@COND_TOOLKIT_GTK@OPENGL_PLATFORM_HDR = wx/gtk/glcanvas.h \
@COND_TOOLKIT_GTK@ wx/unix/glcanvas.h
@COND_TOOLKIT_MSW@OPENGL_PLATFORM_HDR = wx/msw/glcanvas.h
@COND_TOOLKIT_OSX_COCOA@OPENGL_PLATFORM_HDR = wx/osx/glcanvas.h
@COND_TOOLKIT_OSX_IPHONE@OPENGL_PLATFORM_HDR = wx/osx/glcanvas.h
@COND_TOOLKIT_QT@OPENGL_PLATFORM_HDR = wx/qt/glcanvas.h
@COND_TOOLKIT_X11@OPENGL_PLATFORM_HDR = wx/unix/glx11.h wx/x11/glcanvas.h
@COND_TOOLKIT_X11@OPENGL_PLATFORM_HDR = wx/x11/glcanvas.h \
@COND_TOOLKIT_X11@ wx/unix/glcanvas.h
@COND_TOOLKIT_GTK_TOOLKIT_VERSION_2@AUI_PLATFORM_HDR = wx/aui/tabartgtk.h
@COND_TOOLKIT_MSW@AUI_PLATFORM_HDR = wx/aui/tabartmsw.h wx/aui/barartmsw.h
COND_PLATFORM_MACOSX_1_BASE_PLATFORM_HDR = \
@@ -12155,7 +12156,8 @@ COND_USE_SOVERSOLARIS_1___gldll___so_symlinks_uninst_cmd = rm -f \
@COND_USE_SOVERSOLARIS_1@__gldll___so_symlinks_uninst_cmd = $(COND_USE_SOVERSOLARIS_1___gldll___so_symlinks_uninst_cmd)
@COND_PLATFORM_WIN32_1@__gldll___win32rc = gldll_version_rc.o
@COND_TOOLKIT_GTK@__OPENGL_PLATFORM_SRC_OBJECTS = \
@COND_TOOLKIT_GTK@ gldll_glx11.o gldll_gtk_glcanvas.o gldll_glegl.o
@COND_TOOLKIT_GTK@ gldll_glx11.o gldll_gtk_glcanvas.o gldll_glegl.o \
@COND_TOOLKIT_GTK@ gldll_unix_glcanvas.o
@COND_TOOLKIT_MSW@__OPENGL_PLATFORM_SRC_OBJECTS = gldll_msw_glcanvas.o
@COND_TOOLKIT_OSX_COCOA@__OPENGL_PLATFORM_SRC_OBJECTS \
@COND_TOOLKIT_OSX_COCOA@ = gldll_glcanvas_osx.o gldll_cocoa_glcanvas.o
@@ -12163,7 +12165,7 @@ COND_USE_SOVERSOLARIS_1___gldll___so_symlinks_uninst_cmd = rm -f \
@COND_TOOLKIT_OSX_IPHONE@ = gldll_glcanvas_osx.o gldll_iphone_glcanvas.o
@COND_TOOLKIT_QT@__OPENGL_PLATFORM_SRC_OBJECTS = gldll_qt_glcanvas.o
@COND_TOOLKIT_X11@__OPENGL_PLATFORM_SRC_OBJECTS = \
@COND_TOOLKIT_X11@ gldll_x11_glcanvas.o gldll_glx11.o
@COND_TOOLKIT_X11@ gldll_x11_glcanvas.o gldll_glx11.o gldll_unix_glcanvas.o
COND_MONOLITHIC_0___WXLIBGLDEP_CORE_p = \
-lwx_$(PORTNAME)$(WXUNIVNAME)u$(WXDEBUGFLAG)$(WX_LIB_FLAVOUR)_core-$(WX_RELEASE)$(HOST_SUFFIX)
@COND_MONOLITHIC_0@__WXLIBGLDEP_CORE_p = $(COND_MONOLITHIC_0___WXLIBGLDEP_CORE_p)
@@ -12186,7 +12188,8 @@ COND_SHARED_0_USE_GUI_1_USE_OPENGL_1___gllib___depname = \
@COND_USE_PCH_1@_____pch_wxprec_gllib_wx_wxprec_h_gch___depname \
@COND_USE_PCH_1@ = ./.pch/wxprec_gllib/wx/wxprec.h.gch
@COND_TOOLKIT_GTK@__OPENGL_PLATFORM_SRC_OBJECTS_1 = \
@COND_TOOLKIT_GTK@ gllib_glx11.o gllib_gtk_glcanvas.o gllib_glegl.o
@COND_TOOLKIT_GTK@ gllib_glx11.o gllib_gtk_glcanvas.o gllib_glegl.o \
@COND_TOOLKIT_GTK@ gllib_unix_glcanvas.o
@COND_TOOLKIT_MSW@__OPENGL_PLATFORM_SRC_OBJECTS_1 = gllib_msw_glcanvas.o
@COND_TOOLKIT_OSX_COCOA@__OPENGL_PLATFORM_SRC_OBJECTS_1 \
@COND_TOOLKIT_OSX_COCOA@ = gllib_glcanvas_osx.o gllib_cocoa_glcanvas.o
@@ -12194,7 +12197,7 @@ COND_SHARED_0_USE_GUI_1_USE_OPENGL_1___gllib___depname = \
@COND_TOOLKIT_OSX_IPHONE@ = gllib_glcanvas_osx.o gllib_iphone_glcanvas.o
@COND_TOOLKIT_QT@__OPENGL_PLATFORM_SRC_OBJECTS_1 = gllib_qt_glcanvas.o
@COND_TOOLKIT_X11@__OPENGL_PLATFORM_SRC_OBJECTS_1 = \
@COND_TOOLKIT_X11@ gllib_x11_glcanvas.o gllib_glx11.o
@COND_TOOLKIT_X11@ gllib_x11_glcanvas.o gllib_glx11.o gllib_unix_glcanvas.o
@COND_SHARED_1@____wxgl_namedll_DEP = $(__gldll___depname)
@COND_SHARED_0@____wxgl_namelib_DEP = $(__gllib___depname)
COND_WITH_PLUGIN_SDL_1___sound_sdl___depname = \
@@ -34418,6 +34421,12 @@ gldll_x11_glcanvas.o: $(srcdir)/src/x11/glcanvas.cpp $(GLDLL_ODEP)
@COND_TOOLKIT_X11@gldll_glx11.o: $(srcdir)/src/unix/glx11.cpp $(GLDLL_ODEP)
@COND_TOOLKIT_X11@ $(CXXC) -c -o $@ $(GLDLL_CXXFLAGS) $(srcdir)/src/unix/glx11.cpp
@COND_TOOLKIT_GTK@gldll_unix_glcanvas.o: $(srcdir)/src/unix/glcanvas.cpp $(GLDLL_ODEP)
@COND_TOOLKIT_GTK@ $(CXXC) -c -o $@ $(GLDLL_CXXFLAGS) $(srcdir)/src/unix/glcanvas.cpp
@COND_TOOLKIT_X11@gldll_unix_glcanvas.o: $(srcdir)/src/unix/glcanvas.cpp $(GLDLL_ODEP)
@COND_TOOLKIT_X11@ $(CXXC) -c -o $@ $(GLDLL_CXXFLAGS) $(srcdir)/src/unix/glcanvas.cpp
gllib_glcmn.o: $(srcdir)/src/common/glcmn.cpp $(GLLIB_ODEP)
$(CXXC) -c -o $@ $(GLLIB_CXXFLAGS) $(srcdir)/src/common/glcmn.cpp
@@ -34454,6 +34463,12 @@ gllib_x11_glcanvas.o: $(srcdir)/src/x11/glcanvas.cpp $(GLLIB_ODEP)
@COND_TOOLKIT_X11@gllib_glx11.o: $(srcdir)/src/unix/glx11.cpp $(GLLIB_ODEP)
@COND_TOOLKIT_X11@ $(CXXC) -c -o $@ $(GLLIB_CXXFLAGS) $(srcdir)/src/unix/glx11.cpp
@COND_TOOLKIT_GTK@gllib_unix_glcanvas.o: $(srcdir)/src/unix/glcanvas.cpp $(GLLIB_ODEP)
@COND_TOOLKIT_GTK@ $(CXXC) -c -o $@ $(GLLIB_CXXFLAGS) $(srcdir)/src/unix/glcanvas.cpp
@COND_TOOLKIT_X11@gllib_unix_glcanvas.o: $(srcdir)/src/unix/glcanvas.cpp $(GLLIB_ODEP)
@COND_TOOLKIT_X11@ $(CXXC) -c -o $@ $(GLLIB_CXXFLAGS) $(srcdir)/src/unix/glcanvas.cpp
sound_sdl_sound_sdl.o: $(srcdir)/src/unix/sound_sdl.cpp
$(CXXC) -c -o $@ $(SOUND_SDL_CXXFLAGS) $(srcdir)/src/unix/sound_sdl.cpp

7
build/bakefiles/files.bkl
View File

@@ -2908,12 +2908,12 @@ IMPORTANT: please read docs/tech/tn0016.txt before modifying this file!
src/unix/glx11.cpp
src/gtk/glcanvas.cpp
src/unix/glegl.cpp
src/unix/glcanvas.cpp
</set>
<set var="OPENGL_GTK_HDR" hints="files">
wx/unix/glx11.h
wx/gtk/glcanvas.h
wx/unix/glegl.h
wx/unix/glcanvas.h
</set>
<set var="OPENGL_OSX_COCOA_SRC" hints="files">
@@ -2937,11 +2937,12 @@ IMPORTANT: please read docs/tech/tn0016.txt before modifying this file!
<set var="OPENGL_X11_SRC" hints="files">
src/x11/glcanvas.cpp
src/unix/glx11.cpp
src/unix/glcanvas.cpp
</set>
<set var="OPENGL_X11_HDR" hints="files">
wx/unix/glx11.h
wx/x11/glcanvas.h
wx/unix/glcanvas.h
</set>
<set var="OPENGL_QT_SRC" hints="files">

7
build/cmake/files.cmake
View File

@@ -2700,12 +2700,12 @@ set(OPENGL_GTK_SRC
src/gtk/glcanvas.cpp
src/unix/glx11.cpp
src/unix/glegl.cpp
src/unix/glcanvas.cpp
)
set(OPENGL_GTK_HDR
wx/gtk/glcanvas.h
wx/unix/glx11.h
wx/unix/glegl.h
wx/unix/glcanvas.h
)
set(OPENGL_OSX_COCOA_SRC
@@ -2729,11 +2729,12 @@ set(OPENGL_OSX_IPHONE_HDR
set(OPENGL_X11_SRC
src/x11/glcanvas.cpp
src/unix/glx11.cpp
src/unix/glcanvas.cpp
)
set(OPENGL_X11_HDR
wx/x11/glcanvas.h
wx/unix/glx11.h
wx/unix/glcanvas.h
)
set(OPENGL_QT_SRC

1
build/cmake/init.cmake
View File

@@ -537,6 +537,7 @@ if(wxUSE_GUI)
# library directly like this to avoid link problems.
set(OPENGL_LIBRARIES ${OPENGL_egl_LIBRARY} ${OPENGL_LIBRARIES})
endif()
set(wxHAS_EGL 1)
set(OPENGL_INCLUDE_DIR ${OPENGL_INCLUDE_DIR} ${OPENGL_EGL_INCLUDE_DIRS})
find_package(WAYLANDEGL)
if(WAYLANDEGL_FOUND AND wxHAVE_GDK_WAYLAND)

5
build/cmake/setup.h.in
View File

@@ -497,8 +497,6 @@
#cmakedefine01 wxUSE_GLCANVAS
#cmakedefine01 wxUSE_GLCANVAS_EGL
#cmakedefine01 wxUSE_RICHTEXT
@@ -1130,6 +1128,9 @@
/* Define if locale_t is available */
#cmakedefine HAVE_LOCALE_T 1
/* Define if you have EGL support */
#cmakedefine wxHAS_EGL 1
/* Define if you have inotify_xxx() functions. */
#cmakedefine wxHAS_INOTIFY 1

7
build/files
View File

@@ -2668,13 +2668,13 @@ OPENGL_MSW_HDR =
OPENGL_GTK_SRC =
src/gtk/glcanvas.cpp
src/unix/glcanvas.cpp
src/unix/glegl.cpp
src/unix/glx11.cpp
OPENGL_GTK_HDR =
wx/gtk/glcanvas.h
wx/unix/glegl.h
wx/unix/glx11.h
wx/unix/glcanvas.h
OPENGL_OSX_COCOA_SRC =
src/osx/cocoa/glcanvas.mm
@@ -2691,11 +2691,12 @@ OPENGL_OSX_IPHONE_HDR =
wx/osx/glcanvas.h
OPENGL_X11_SRC =
src/unix/glcanvas.cpp
src/unix/glx11.cpp
src/x11/glcanvas.cpp
OPENGL_X11_HDR =
wx/unix/glx11.h
wx/unix/glcanvas.h
wx/x11/glcanvas.h
OPENGL_QT_SRC =

53
configure vendored
View File

@@ -1362,7 +1362,6 @@ enable_accessibility
enable_uiactionsim
enable_dctransform
enable_webviewwebkit
enable_glcanvasegl
enable_palette
enable_image
enable_gif
@@ -2339,7 +2338,6 @@ Optional Features:
--enable-uiactionsim use wxUIActionSimulator
--enable-dctransform use wxDC::SetTransformMatrix and related
--enable-webviewwebkit use wxWebView WebKit backend
--disable-glcanvasegl disable wxGLCanvas EGL backend
--enable-palette use wxPalette class
--enable-image use wxImage class
--enable-gif use gif images (GIF file format)
@@ -12374,35 +12372,6 @@ fi
eval "$wx_cv_use_webviewwebkit"
enablestring=
defaultval=$wxUSE_ALL_FEATURES
if test -z "$defaultval"; then
if test x"$enablestring" = xdisable; then
defaultval=yes
else
defaultval=no
fi
fi
# Check whether --enable-glcanvasegl was given.
if test "${enable_glcanvasegl+set}" = set; then :
enableval=$enable_glcanvasegl;
if test "$enableval" = yes; then
wx_cv_use_glcanvasegl='wxUSE_GLCANVAS_EGL=yes'
else
wx_cv_use_glcanvasegl='wxUSE_GLCANVAS_EGL=no'
fi
else
wx_cv_use_glcanvasegl='wxUSE_GLCANVAS_EGL=${'DEFAULT_wxUSE_GLCANVAS_EGL":-$defaultval}"
fi
eval "$wx_cv_use_glcanvasegl"
enablestring=
@@ -31298,7 +31267,6 @@ fi
OPENGL_LIBS="-lGL"
if test "$WXGTK3" = 1; then
if test "$wxUSE_GLCANVAS_EGL" != "no"; then
pkg_failed=no
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egl >= 1.4" >&5
@@ -31359,7 +31327,7 @@ fi
echo "$EGL_PKG_ERRORS" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: EGL 1.4+ not available. Will use GLX." >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: EGL 1.4+ not available. Will use GLX." >&5
$as_echo "$as_me: EGL 1.4+ not available. Will use GLX." >&6;}
@@ -31367,7 +31335,7 @@ elif test $pkg_failed = untried; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: EGL 1.4+ not available. Will use GLX." >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: EGL 1.4+ not available. Will use GLX." >&5
$as_echo "$as_me: EGL 1.4+ not available. Will use GLX." >&6;}
@@ -31377,8 +31345,8 @@ else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
OPENGL_LIBS="$OPENGL_LIBS $EGL_LIBS"
$as_echo "#define wxUSE_GLCANVAS_EGL 1" >>confdefs.h
OPENGL_LIBS="$OPENGL_LIBS $EGL_LIBS"
$as_echo "#define wxHAS_EGL 1" >>confdefs.h
pkg_failed=no
@@ -31452,18 +31420,17 @@ else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
if test $wx_cv_gdk_wayland = "yes"; then
OPENGL_LIBS="$OPENGL_LIBS $WAYLAND_EGL_LIBS"
have_wayland=1
fi
if test $wx_cv_gdk_wayland = "yes"; then
OPENGL_LIBS="$OPENGL_LIBS $WAYLAND_EGL_LIBS"
have_wayland=1
fi
fi
fi
if test "$have_wayland" != 1; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: wxGLCanvas will not have Wayland support" >&5
if test "$have_wayland" != 1; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: wxGLCanvas will not have Wayland support" >&5
$as_echo "$as_me: wxGLCanvas will not have Wayland support" >&6;}
fi
fi
fi
fi

2
configure.ac
View File

@@ -3461,7 +3461,7 @@ if test "$wxUSE_OPENGL" = "yes" -o "$wxUSE_OPENGL" = "auto"; then
PKG_CHECK_MODULES(EGL, [egl >= 1.4],
[
OPENGL_LIBS="$OPENGL_LIBS $EGL_LIBS"
AC_DEFINE(wxUSE_GLCANVAS_EGL)
AC_DEFINE(wxHAS_EGL)
PKG_CHECK_MODULES(WAYLAND_EGL, [wayland-egl],
[
if test $wx_cv_gdk_wayland = "yes"; then

4
docs/changes.txt
View File

@@ -237,6 +237,10 @@ Changes in behaviour which may result in build errors
previously compiled doesn't compile any longer, please fix it to use either
the ctor from RGB value or from string explicitly.
- wxGLCanvas::CreateSurface() which was previously enabled in build
configurations using EGL is not available any longer as exposing it doesn't
make sense when wxGLCanvas may use either EGL or GLX.
3.3.2: (released 2025-??-??)
----------------------------

4
docs/doxygen/mainpages/const_cpp.h
View File

@@ -187,6 +187,10 @@ Currently the following symbols exist:
ever, be necessary to use this symbol directly, functions such as
wxWindow::FromDIP() and wxBitmap::GetLogicalSize() exist to hide the
differences between the platforms with and without DPI-independent pixels.}
@itemdef{wxHAS_EGL, Defined if wxGLCanvas may use EGL for OpenGL context
creation (this symbol only exists in wxWidgets 3.3.2 and later).}
@itemdef{wxHAS_GLX, Defined if wxGLCanvas may use GLX for OpenGL context
creation (this symbol only exists in wxWidgets 3.3.2 and later).}
@itemdef{wxHAS_IMAGE_RESOURCES, Defined if wxICON() and wxBITMAP() macros use
images from (Windows) resources. Otherwise, these macros use XPMs.}
@itemdef{wxHAS_MEMBER_DEFAULT, Defined if the currently used compiler supports

8
include/wx/android/setup.h
View File

@@ -1321,14 +1321,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

36
include/wx/glcanvas.h
View File

@@ -20,14 +20,10 @@
// Most ports have a single implementation of wxGLCanvas, but wxGTK has two:
// legacy GLX-based one (also used by wxX11) and EGL-based one which is used
// when enabled by wxUSE_GLCANVAS_EGL. Although it is not user-settable, define
// wxUSE_GLCANVAS_GLX for consistency.
#if defined(__WXX11__)
#define wxUSE_GLCANVAS_GLX 1
#elif defined(__WXGTK__)
#define wxUSE_GLCANVAS_GLX (!wxUSE_GLCANVAS_EGL)
#else
#define wxUSE_GLCANVAS_GLX 0
// if support for EGL is available. wxHAS_EGL is defined by the build system
// but define wxHAS_GLX too for consistency, even if it's always available.
#if defined(__WXX11__) || defined(__WXGTK__)
#define wxHAS_GLX 1
#endif
class WXDLLIMPEXP_FWD_GL wxGLCanvas;
@@ -146,16 +142,16 @@ public:
wxGLContextAttrs& PlatformDefaults();
void EndList(); // No more values can be chained
#if wxUSE_GLCANVAS_GLX
#ifdef wxHAS_GLX
// Currently only used for X11 context creation
bool x11Direct = false; // X11 direct render
bool renderTypeRGBA = false;
#endif // wxUSE_GLCANVAS_GLX
#endif // wxHAS_GLX
#if wxUSE_GLCANVAS_EGL
#ifdef wxHAS_EGL
// Used to select the kind of API used with EGL (OpenGL or OpenGL ES).
bool useES = false;
#endif // wxUSE_GLCANVAS_EGL
#endif // wxHAS_EGL
};
// ----------------------------------------------------------------------------
@@ -283,25 +279,27 @@ public:
// as a parameter
wxGLContextAttrs& GetGLCTXAttrs() { return m_GLCTXAttrs; }
protected:
// override this to implement SetColour() in GL_INDEX_MODE
// (currently only implemented in wxX11)
virtual int GetColourIndex(const wxColour& WXUNUSED(col)) { return -1; }
// Implementation only from now on.
// check if the given extension name is present in the space-separated list
// of extensions supported by the current implementation such as returned
// by glXQueryExtensionsString() or glGetString(GL_EXTENSIONS)
static bool IsExtensionInList(const char *list, const char *extension);
// For the case of "int* attribList" at ctor is != 0
wxGLContextAttrs m_GLCTXAttrs;
// Extract pixel format and context attributes.
// Return false if an unknown attribute is found.
static bool ParseAttribList(const int* attribList,
wxGLAttributes& dispAttrs,
wxGLContextAttrs* ctxAttrs = nullptr);
protected:
// override this to implement SetColour() in GL_INDEX_MODE
// (currently only implemented in wxX11)
virtual int GetColourIndex(const wxColour& WXUNUSED(col)) { return -1; }
// For the case of "int* attribList" at ctor is != 0
wxGLContextAttrs m_GLCTXAttrs;
#if wxUSE_PALETTE
// create default palette if we're not using RGBA mode
// (not supported in most ports)

15
include/wx/gtk/glcanvas.h
View File

@@ -10,23 +10,14 @@
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#include "wx/setup.h"
#if wxUSE_GLCANVAS_EGL
#include "wx/unix/glegl.h"
typedef wxGLCanvasEGL wxGLCanvasImpl;
#else
#include "wx/unix/glx11.h"
typedef wxGLCanvasX11 wxGLCanvasImpl;
#endif
#include "wx/unix/glcanvas.h"
//---------------------------------------------------------------------------
// wxGLCanvas
//---------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasImpl
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasUnix
{
typedef wxGLCanvasImpl BaseType;
public:
wxGLCanvas() = default;
@@ -69,7 +60,7 @@ public:
virtual bool SetBackgroundStyle(wxBackgroundStyle style) override;
// implement wxGLCanvasX11 methods
// implement wxGLCanvasUnix methods
// --------------------------------
virtual unsigned long GetXWindow() const override;

8
include/wx/gtk/setup.h
View File

@@ -1321,14 +1321,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

8
include/wx/msw/setup.h
View File

@@ -1321,14 +1321,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

8
include/wx/osx/setup.h
View File

@@ -1328,14 +1328,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

8
include/wx/setup_inc.h
View File

@@ -1317,14 +1317,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

8
include/wx/univ/setup.h
View File

@@ -1321,14 +1321,6 @@
// otherwise.
#define wxUSE_GLCANVAS 1
// Setting wxUSE_GLCANVAS_EGL to 1 enables OpenGL EGL backend. This will be
// automatically enabled if EGL support is detected. EGL support is only
// available under Unix platforms.
//
// Default is 0.
//
#define wxUSE_GLCANVAS_EGL 0
// wxRichTextCtrl allows editing of styled text.
//
// Default is 1.

88
include/wx/unix/glx11.h → include/wx/unix/glcanvas.h
View File

@@ -1,22 +1,27 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/glx11.h
// Purpose: class common for all X11-based wxGLCanvas implementations
// Name: wx/unix/glcanvas.h
// Purpose: class common for wxGLCanvas implementations in wxGTK and wxX11
// Author: Vadim Zeitlin
// Created: 2007-04-15
// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_GLX11_H_
#define _WX_UNIX_GLX11_H_
#ifndef _WX_UNIX_GLCANVAS_H_
#define _WX_UNIX_GLCANVAS_H_
#include <memory>
#include <GL/gl.h>
typedef struct __GLXcontextRec* GLXContext;
// Forward declare struct from GL/glx.h
typedef struct __GLXFBConfigRec* GLXFBConfig;
class wxGLContextImpl;
class wxGLCanvasUnixImpl;
// ----------------------------------------------------------------------------
// wxGLContext
// wxGLContext: used as is in all ports
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLContext : public wxGLContextBase
@@ -29,41 +34,35 @@ public:
virtual bool SetCurrent(const wxGLCanvas& win) const override;
// Implementation only.
wxGLContextImpl* GetImpl() const { return m_impl.get(); }
private:
GLXContext m_glContext;
std::unique_ptr<wxGLContextImpl> m_impl;
wxDECLARE_CLASS(wxGLContext);
};
// ----------------------------------------------------------------------------
// wxGLCanvasX11
// wxGLCanvasUnix: base class for port-specific wxGLCanvas
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvasX11 : public wxGLCanvasBase
class WXDLLIMPEXP_GL wxGLCanvasUnix : public wxGLCanvasBase
{
public:
// initialization and dtor
// -----------------------
// default ctor doesn't do anything, InitVisual() must be called
wxGLCanvasX11();
// initializes GLXFBConfig and XVisualInfo corresponding to the given attributes
bool InitVisual(const wxGLAttributes& dispAttrs);
// frees XVisualInfo info
virtual ~wxGLCanvasX11();
// implement wxGLCanvasBase methods
// --------------------------------
virtual ~wxGLCanvasUnix();
virtual bool SwapBuffers() override;
virtual bool IsShownOnScreen() const override;
// X11-specific methods
// GLX-specific methods
// --------------------
// if both GLX and EGL are available, prefer using GLX instead of EGL used
// by default
static void PreferGLX();
// return GLX version: 13 means 1.3 &c
static int GetGLXVersion();
@@ -74,33 +73,21 @@ public:
virtual unsigned long GetXWindow() const = 0;
// GLX-specific methods
// --------------------
// Implementation only.
wxGLCanvasUnixImpl* GetImpl() const { return m_impl.get(); }
// override some wxWindow methods
// ------------------------------
void* GetXVisualInfo() const;
// return true only if the window is realized: OpenGL context can't be
// created until we are
virtual bool IsShownOnScreen() const override;
protected:
wxGLCanvasUnix();
bool InitVisual(const wxGLAttributes& dispAttrs);
// implementation only from now on
// -------------------------------
// get the GLXFBConfig/XVisualInfo we use
GLXFBConfig *GetGLXFBConfig() const { return m_fbc; }
void* GetXVisualInfo() const { return m_vi; }
// initialize the global default GL visual, return false if matching visual
// not found
static bool InitDefaultVisualInfo(const int *attribList);
// This is only called by wxGTK but defined in any case.
void CallOnRealized();
private:
GLXFBConfig *m_fbc;
void* m_vi;
bool m_swapIntervalSet = false;
std::unique_ptr<wxGLCanvasUnixImpl> m_impl;
};
// ----------------------------------------------------------------------------
@@ -113,11 +100,11 @@ private:
class WXDLLIMPEXP_GL wxGLApp : public wxGLAppBase
{
public:
wxGLApp() = default;
virtual bool InitGLVisual(const int *attribList) override;
#ifndef __WXGTK3__
virtual void* GetXVisualInfo() override;
#endif // GTK < 3
virtual void* GetXVisualInfo();
// and override this wxApp method to clean up
virtual int OnExit() override;
@@ -126,5 +113,4 @@ private:
wxDECLARE_DYNAMIC_CLASS(wxGLApp);
};
#endif // _WX_UNIX_GLX11_H_
#endif // _WX_UNIX_GLCANVAS_H_

205
include/wx/unix/glegl.h
View File

@@ -1,205 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/glegl.h
// Purpose: class common for all EGL-based wxGLCanvas implementations
// Author: Scott Talbert
// Created: 2017-12-26
// Copyright: (c) 2017 Scott Talbert <swt@techie.net>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_GLEGL_H_
#define _WX_UNIX_GLEGL_H_
#include <GL/gl.h>
// This is to avoid including Wayland & EGL headers here to pollute namespace
struct wl_compositor;
struct wl_subcompositor;
struct wl_callback;
struct wl_egl_window;
struct wl_surface;
struct wl_region;
struct wl_subsurface;
typedef void *EGLDisplay;
typedef void *EGLConfig;
typedef void *EGLSurface;
typedef void *EGLContext;
class wxGLContextAttrs;
class wxGLAttributes;
// ----------------------------------------------------------------------------
// wxGLContext
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLContext : public wxGLContextBase
{
public:
wxGLContext(wxGLCanvas *win,
const wxGLContext *other = nullptr,
const wxGLContextAttrs *ctxAttrs = nullptr);
virtual ~wxGLContext();
virtual bool SetCurrent(const wxGLCanvas& win) const override;
private:
EGLContext m_glContext;
wxDECLARE_CLASS(wxGLContext);
};
// ----------------------------------------------------------------------------
// wxGLCanvasEGL
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_GL wxGLCanvasEGL : public wxGLCanvasBase
{
public:
// initialization and dtor
// -----------------------
// default ctor doesn't do anything, InitConfig() must be called
wxGLCanvasEGL() = default;
// initializes EGLConfig corresponding to the given attributes
bool InitVisual(const wxGLAttributes& dispAttrs);
// creates EGLSurface
bool CreateSurface();
virtual ~wxGLCanvasEGL();
// Wayland-specific callbacks
// --------------------------
void CreateWaylandSubsurface();
void DestroyWaylandSubsurface();
// implement wxGLCanvasBase methods
// --------------------------------
virtual bool SwapBuffers() override;
// X11-specific methods
// --------------------
// get the X11 handle of this window
virtual unsigned long GetXWindow() const = 0;
// override some wxWindow methods
// ------------------------------
// return true only if the window is realized: OpenGL context can't be
// created until we are
virtual bool IsShownOnScreen() const override;
// implementation only from now on
// -------------------------------
// get the EGLConfig we use
EGLConfig GetEGLConfig() const { return m_config; }
EGLDisplay GetEGLDisplay() const { return m_display; }
EGLSurface GetEGLSurface() const { return m_surface; }
static EGLDisplay GetDisplay();
// initialize the global default GL config, return false if matching config
// not found
static bool InitDefaultConfig(const int *attribList);
// get the default EGL Config (may be null, shouldn't be freed by caller)
static EGLConfig GetDefaultConfig() { return ms_glEGLConfig; }
// free the global GL visual, called by wxGLApp
static void FreeDefaultConfig();
// initializes EGLConfig
//
// returns nullptr if EGLConfig couldn't be initialized, otherwise caller
// is responsible for freeing the pointer
static EGLConfig InitConfig(const wxGLAttributes& dispAttrs);
// Only called when using Wayland to indicate that we should be redrawn.
void OnWLFrameCallback();
wl_compositor *m_wlCompositor = nullptr;
wl_subcompositor *m_wlSubcompositor = nullptr;
wl_callback *m_wlFrameCallbackHandler = nullptr;
wl_egl_window *m_wlEGLWindow = nullptr;
private:
// Set correct m_wlSubsurface position.
//
// This is defined only when using Wayland.
void UpdateSubsurfacePosition();
// Call eglCreatePlatformWindowSurface() when using EGL 1.5 or later,
// otherwise try eglCreatePlatformWindowSurfaceEXT() if it's available and
// fall back on eglCreateWindowSurface() otherwise.
//
// This function uses m_display and m_config which must be initialized
// before using it and should be passed either m_xwindow or m_wlEGLWindow
// depending on whether we are using X11 or Wayland.
EGLSurface CallCreatePlatformWindowSurface(void *window) const;
EGLConfig m_config = nullptr;
EGLDisplay m_display = nullptr;
EGLSurface m_surface = nullptr;
unsigned long m_xwindow = 0;
wl_surface *m_wlSurface = nullptr;
wl_region *m_wlRegion = nullptr;
wl_subsurface *m_wlSubsurface = nullptr;
bool m_readyToDraw = false;
bool m_swapIntervalSet = false;
// the global/default versions of the above
static EGLConfig ms_glEGLConfig;
// Called from GTK callbacks and needs access to private members.
friend void wxEGLUpdateGeometry(GtkWidget* widget, wxGLCanvasEGL* win);
};
// ----------------------------------------------------------------------------
// wxGLApp
// ----------------------------------------------------------------------------
// this is used in wx/glcanvas.h, prevent it from defining a generic wxGLApp
#define wxGL_APP_DEFINED
class WXDLLIMPEXP_GL wxGLApp : public wxGLAppBase
{
public:
wxGLApp() : wxGLAppBase() { }
// implement wxGLAppBase method
virtual bool InitGLVisual(const int *attribList) override
{
return wxGLCanvasEGL::InitDefaultConfig(attribList);
}
#ifndef __WXGTK3__
virtual void* GetXVisualInfo() override
{
return wxGLCanvasEGL::GetDefaultConfig();
}
#endif // GTK < 3
// and override this wxApp method to clean up
virtual int OnExit() override
{
wxGLCanvasEGL::FreeDefaultConfig();
return wxGLAppBase::OnExit();
}
private:
wxDECLARE_DYNAMIC_CLASS(wxGLApp);
};
#endif // _WX_UNIX_GLEGL_H_

162
include/wx/unix/private/glcanvas.h Normal file
View File

@@ -0,0 +1,162 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/glcontext.h
// Purpose: Base class for Unix-specific wxGLContext implementation
// Author: Vadim Zeitlin
// Created: 2025-12-07
// Copyright: (c) 2025 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_GLCANVAS_H_
#define _WX_UNIX_PRIVATE_GLCANVAS_H_
// ----------------------------------------------------------------------------
// wxGLContextImpl is used by wxGLContext to implement its functionality
// ----------------------------------------------------------------------------
class wxGLContextImpl
{
public:
virtual ~wxGLContextImpl() = default;
virtual bool SetCurrent(const wxGLCanvas& win) const = 0;
bool IsOK() const { return m_isOk; }
protected:
wxGLContextImpl() = default;
// This is similar to wxGLContextBase::m_isOk and allows to keep the
// code from before the refactoring which introduced this class unchanged.
bool m_isOk = false;
wxDECLARE_NO_COPY_CLASS(wxGLContextImpl);
};
// ----------------------------------------------------------------------------
// wxGLCanvasUnixImpl: note that this is not a wxWindow-derived class
// ----------------------------------------------------------------------------
class wxGLCanvasUnixImpl
{
public:
virtual ~wxGLCanvasUnixImpl() = default;
virtual bool InitVisual(const wxGLAttributes& dispAttrs) = 0;
virtual bool SwapBuffers() = 0;
virtual void OnRealized() = 0;
virtual bool HasWindow() const = 0;
virtual void* GetXVisualInfo() const = 0;
protected:
explicit wxGLCanvasUnixImpl(wxGLCanvasUnix* canvas)
: m_canvas(canvas)
{
}
wxGLCanvasUnix* const m_canvas;
wxDECLARE_NO_COPY_CLASS(wxGLCanvasUnixImpl);
};
// ----------------------------------------------------------------------------
// wxGLBackend: used for creating implementation objects and implementing other
// non-member functions.
// ----------------------------------------------------------------------------
class wxGLBackend
{
public:
#ifdef wxHAS_EGL
// This can be called only before calling Get() for the first time.
static void PreferGLX();
#endif // wxHAS_EGL
// Get the (sole) instance of this class.
static wxGLBackend& Get()
{
if ( !ms_instance )
ms_instance = Init();
return *ms_instance;
}
wxGLBackend(const wxGLBackend&) = delete;
wxGLBackend& operator=(const wxGLBackend&) = delete;
virtual ~wxGLBackend() = default;
// Factory functions for creating the implementation objects.
virtual std::unique_ptr<wxGLContextImpl>
CreateContextImpl(wxGLCanvas* win,
const wxGLContext* other,
const wxGLContextAttrs* ctxAttrs) = 0;
virtual std::unique_ptr<wxGLCanvasUnixImpl>
CreateCanvasImpl(wxGLCanvasUnix* canvas) = 0;
// Static functions of wxGLContext and wxGLCanvas.
virtual void ClearCurrentContext() = 0;
virtual bool IsExtensionSupported(const char* extension) = 0;
virtual bool IsDisplaySupported(const wxGLAttributes& dispAttrs) = 0;
virtual int GetGLXVersion() = 0;
virtual bool IsGLXMultiSampleAvailable() = 0;
// wxGLApp functions implementation.
virtual bool InitDefaultVisualInfo(const int* attribList) = 0;
virtual void* GetDefaultVisualInfo() = 0;
virtual void FreeDefaultVisualInfo() = 0;
// wxGLContextAttrs functions implementation.
virtual wxGLContextAttrs& CoreProfile(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& MajorVersion(wxGLContextAttrs& attrs, int val) = 0;
virtual wxGLContextAttrs& MinorVersion(wxGLContextAttrs& attrs, int val) = 0;
virtual wxGLContextAttrs& CompatibilityProfile(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& ForwardCompatible(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& ES2(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& DebugCtx(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& Robust(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& NoResetNotify(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& LoseOnReset(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& ResetIsolation(wxGLContextAttrs& attrs) = 0;
virtual wxGLContextAttrs& ReleaseFlush(wxGLContextAttrs& attrs, int val) = 0;
virtual wxGLContextAttrs& PlatformDefaults(wxGLContextAttrs& attrs) = 0;
// wxGLAttributes functions implementation.
virtual wxGLAttributes& RGBA(wxGLAttributes& attrs) = 0;
virtual wxGLAttributes& BufferSize(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& Level(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& DoubleBuffer(wxGLAttributes& attrs) = 0;
virtual wxGLAttributes& Stereo(wxGLAttributes& attrs) = 0;
virtual wxGLAttributes& AuxBuffers(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& MinRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) = 0;
virtual wxGLAttributes& Depth(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& Stencil(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& MinAcumRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) = 0;
virtual wxGLAttributes& PlatformDefaults(wxGLAttributes& attrs) = 0;
virtual wxGLAttributes& SampleBuffers(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& Samplers(wxGLAttributes& attrs, int val) = 0;
virtual wxGLAttributes& FrameBuffersRGB(wxGLAttributes& attrs) = 0;
// Both kinds of attributes are terminated in the same way.
virtual void EndList(wxGLAttribsBase& attrs) = 0;
protected:
wxGLBackend() = default;
private:
static wxGLBackend* Init();
static wxGLBackend* ms_instance;
};
#endif // _WX_UNIX_PRIVATE_GLCANVAS_H_

188
include/wx/unix/private/glegl.h Normal file
View File

@@ -0,0 +1,188 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/glegl.h
// Purpose: wxGLContext EGL-based implementation
// Author: Vadim Zeitlin
// Created: 2025-12-07
// Copyright: (c) 2025 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_GLEGL_H_
#define _WX_UNIX_PRIVATE_GLEGL_H_
#include "wx/unix/private/glcanvas.h"
#include <EGL/egl.h>
#include <EGL/eglext.h>
struct wl_compositor;
struct wl_subcompositor;
struct wl_callback;
struct wl_egl_window;
struct wl_surface;
struct wl_region;
struct wl_subsurface;
// ----------------------------------------------------------------------------
// wxGLContextEGL
// ----------------------------------------------------------------------------
class wxGLContextEGL : public wxGLContextImpl
{
public:
wxGLContextEGL(wxGLCanvas *win,
const wxGLContext *other = nullptr,
const wxGLContextAttrs *ctxAttrs = nullptr);
virtual ~wxGLContextEGL();
virtual bool SetCurrent(const wxGLCanvas& win) const override;
private:
EGLContext m_glContext;
};
// ----------------------------------------------------------------------------
// wxGLCanvasEGL
// ----------------------------------------------------------------------------
class wxGLCanvasEGL : public wxGLCanvasUnixImpl
{
public:
explicit wxGLCanvasEGL(wxGLCanvasUnix* canvas)
: wxGLCanvasUnixImpl(canvas)
{
}
virtual ~wxGLCanvasEGL() override;
virtual bool InitVisual(const wxGLAttributes& dispAttrs) override;
virtual bool SwapBuffers() override;
virtual void OnRealized() override;
virtual bool HasWindow() const override;
virtual void* GetXVisualInfo() const override { return nullptr; }
// implementation only from now on
// -------------------------------
void CreateWaylandSubsurface();
void DestroyWaylandSubsurface();
EGLConfig GetEGLConfig() const { return m_config; }
EGLDisplay GetEGLDisplay() const { return m_display; }
EGLSurface GetEGLSurface() const { return m_surface; }
static EGLDisplay GetDisplay();
// initializes EGLConfig
//
// returns nullptr if EGLConfig couldn't be initialized, otherwise caller
// is responsible for freeing the pointer
static EGLConfig InitConfig(const wxGLAttributes& dispAttrs);
// Only called when using Wayland to indicate that we should be redrawn.
void OnWLFrameCallback();
wl_compositor *m_wlCompositor = nullptr;
wl_subcompositor *m_wlSubcompositor = nullptr;
wl_callback *m_wlFrameCallbackHandler = nullptr;
wl_egl_window *m_wlEGLWindow = nullptr;
private:
// Set correct m_wlSubsurface position.
//
// This is defined only when using Wayland.
void UpdateSubsurfacePosition();
// Call eglCreatePlatformWindowSurface() when using EGL 1.5 or later,
// otherwise try eglCreatePlatformWindowSurfaceEXT() if it's available and
// fall back on eglCreateWindowSurface() otherwise.
//
// This function uses m_display and m_config which must be initialized
// before using it and should be passed either m_xwindow or m_wlEGLWindow
// depending on whether we are using X11 or Wayland.
EGLSurface CallCreatePlatformWindowSurface(void *window) const;
EGLConfig m_config = nullptr;
EGLDisplay m_display = nullptr;
EGLSurface m_surface = nullptr;
unsigned long m_xwindow = 0;
wl_surface *m_wlSurface = nullptr;
wl_region *m_wlRegion = nullptr;
wl_subsurface *m_wlSubsurface = nullptr;
bool m_readyToDraw = false;
bool m_swapIntervalSet = false;
// Called from GTK callbacks and needs access to private members.
friend void wxEGLUpdateGeometry(GtkWidget* widget, wxGLCanvasEGL* win);
};
// ----------------------------------------------------------------------------
// wxGLBackendEGL
// ----------------------------------------------------------------------------
class wxGLBackendEGL : public wxGLBackend
{
public:
static wxGLBackend& Get();
wxGLBackendEGL() = default;
std::unique_ptr<wxGLContextImpl>
CreateContextImpl(wxGLCanvas* win,
const wxGLContext* other,
const wxGLContextAttrs* ctxAttrs) override;
std::unique_ptr<wxGLCanvasUnixImpl>
CreateCanvasImpl(wxGLCanvasUnix* canvas) override;
void ClearCurrentContext() override;
bool IsExtensionSupported(const char* extension) override;
bool IsDisplaySupported(const wxGLAttributes& dispAttrs) override;
int GetGLXVersion() override;
bool IsGLXMultiSampleAvailable() override;
bool InitDefaultVisualInfo(const int* attribList) override;
void* GetDefaultVisualInfo() override;
void FreeDefaultVisualInfo() override;
wxGLContextAttrs& CoreProfile(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& MajorVersion(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& MinorVersion(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& CompatibilityProfile(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ForwardCompatible(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ES2(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& DebugCtx(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& Robust(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& NoResetNotify(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& LoseOnReset(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ResetIsolation(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ReleaseFlush(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& PlatformDefaults(wxGLContextAttrs& attrs) override;
wxGLAttributes& RGBA(wxGLAttributes& attrs) override;
wxGLAttributes& BufferSize(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Level(wxGLAttributes& attrs, int val) override;
wxGLAttributes& DoubleBuffer(wxGLAttributes& attrs) override;
wxGLAttributes& Stereo(wxGLAttributes& attrs) override;
wxGLAttributes& AuxBuffers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& MinRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) override;
wxGLAttributes& Depth(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Stencil(wxGLAttributes& attrs, int val) override;
wxGLAttributes& MinAcumRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) override;
wxGLAttributes& PlatformDefaults(wxGLAttributes& attrs) override;
wxGLAttributes& SampleBuffers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Samplers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& FrameBuffersRGB(wxGLAttributes& attrs) override;
void EndList(wxGLAttribsBase& attrs) override;
};
#endif // _WX_UNIX_PRIVATE_GLEGL_H_

131
include/wx/unix/private/glx11.h Normal file
View File

@@ -0,0 +1,131 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/glx11.h
// Purpose: wxGLContext GLX-based implementation for X11
// Author: Vadim Zeitlin
// Created: 2025-12-07
// Copyright: (c) 2025 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_PRIVATE_GLX11_H_
#define _WX_UNIX_PRIVATE_GLX11_H_
#include "wx/unix/private/glcanvas.h"
#include <GL/glx.h>
// ----------------------------------------------------------------------------
// wxGLContextX11
// ----------------------------------------------------------------------------
class wxGLContextX11 : public wxGLContextImpl
{
public:
wxGLContextX11(wxGLCanvas *win,
const wxGLContext *other = nullptr,
const wxGLContextAttrs *ctxAttrs = nullptr);
virtual ~wxGLContextX11();
virtual bool SetCurrent(const wxGLCanvas& win) const override;
private:
GLXContext m_glContext;
};
// ----------------------------------------------------------------------------
// wxGLCanvasX11
// ----------------------------------------------------------------------------
class wxGLCanvasX11 : public wxGLCanvasUnixImpl
{
public:
explicit wxGLCanvasX11(wxGLCanvasUnix* canvas);
virtual ~wxGLCanvasX11() override;
virtual bool InitVisual(const wxGLAttributes& dispAttrs) override;
virtual bool SwapBuffers() override;
virtual void OnRealized() override { /* nothing to do here for GLX */ }
virtual bool HasWindow() const override;
virtual void* GetXVisualInfo() const override { return m_vi; }
GLXFBConfig *GetGLXFBConfig() const { return m_fbc; }
// initialize the global default GL visual, return false if matching visual
// not found
static bool InitDefaultVisualInfo(const int *attribList);
private:
GLXFBConfig *m_fbc;
XVisualInfo* m_vi;
bool m_swapIntervalSet = false;
};
// ----------------------------------------------------------------------------
// wxGLBackendX11
// ----------------------------------------------------------------------------
class wxGLBackendX11 : public wxGLBackend
{
public:
static wxGLBackend& Get();
wxGLBackendX11() = default;
std::unique_ptr<wxGLContextImpl>
CreateContextImpl(wxGLCanvas* win,
const wxGLContext* other,
const wxGLContextAttrs* ctxAttrs) override;
std::unique_ptr<wxGLCanvasUnixImpl>
CreateCanvasImpl(wxGLCanvasUnix* canvas) override;
void ClearCurrentContext() override;
bool IsExtensionSupported(const char* extension) override;
bool IsDisplaySupported(const wxGLAttributes& dispAttrs) override;
int GetGLXVersion() override;
bool IsGLXMultiSampleAvailable() override;
bool InitDefaultVisualInfo(const int* attribList) override;
void* GetDefaultVisualInfo() override;
void FreeDefaultVisualInfo() override;
wxGLContextAttrs& CoreProfile(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& MajorVersion(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& MinorVersion(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& CompatibilityProfile(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ForwardCompatible(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ES2(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& DebugCtx(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& Robust(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& NoResetNotify(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& LoseOnReset(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ResetIsolation(wxGLContextAttrs& attrs) override;
wxGLContextAttrs& ReleaseFlush(wxGLContextAttrs& attrs, int val) override;
wxGLContextAttrs& PlatformDefaults(wxGLContextAttrs& attrs) override;
wxGLAttributes& RGBA(wxGLAttributes& attrs) override;
wxGLAttributes& BufferSize(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Level(wxGLAttributes& attrs, int val) override;
wxGLAttributes& DoubleBuffer(wxGLAttributes& attrs) override;
wxGLAttributes& Stereo(wxGLAttributes& attrs) override;
wxGLAttributes& AuxBuffers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& MinRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) override;
wxGLAttributes& Depth(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Stencil(wxGLAttributes& attrs, int val) override;
wxGLAttributes& MinAcumRGBA(wxGLAttributes& attrs, int mRed, int mGreen, int mBlue, int mAlpha) override;
wxGLAttributes& PlatformDefaults(wxGLAttributes& attrs) override;
wxGLAttributes& SampleBuffers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& Samplers(wxGLAttributes& attrs, int val) override;
wxGLAttributes& FrameBuffersRGB(wxGLAttributes& attrs) override;
void EndList(wxGLAttribsBase& attrs) override;
};
#endif // _WX_UNIX_PRIVATE_GLX11_H_

6
include/wx/x11/glcanvas.h
View File

@@ -11,9 +11,9 @@
#ifndef _WX_GLCANVAS_H_
#define _WX_GLCANVAS_H_
#include "wx/unix/glx11.h"
#include "wx/unix/glcanvas.h"
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasX11
class WXDLLIMPEXP_GL wxGLCanvas : public wxGLCanvasUnix
{
public:
wxGLCanvas() = default;
@@ -55,7 +55,7 @@ public:
const int *attribList = nullptr,
const wxPalette& palette = wxNullPalette);
// implement wxGLCanvasX11 methods
// implement wxGLCanvasUnix methods
// --------------------------------
virtual unsigned long GetXWindow() const;

34
interface/wx/glcanvas.h
View File

@@ -898,18 +898,6 @@ public:
const wxPalette& palette = wxNullPalette);
/**
Re-creates EGLSurface. To be used after a reparent or other
changes that may invalidate the EGL drawing surface.
Only available when wxUSE_GLCANVAS_EGL is enabled.
@return @true if surface is successfully recreated
@since 3.2.3
*/
bool CreateSurface();
/**
Determines if a canvas having the specified attributes is available.
This only applies for visual attributes, not rendering context attributes.
@@ -945,6 +933,28 @@ public:
*/
static bool IsExtensionSupported(const char *extension);
/**
Prefer using GLX over other OpenGL implementations on Unix-like systems
where multiple implementations are available (such as GLX and EGL).
This function is only available when `wxHAS_GLX` preprocessor symbol is
defined (which will be the case for wxGTK and wxX11 under Unix systems).
It must be called before using any OpenGL functionality, which includes
not only creating wxGLCanvas but also checking for extension support or
creating attributes objects, doing it afterwards will trigger an assert
failure and have no other effect.
Note that when using wxGTK with Wayland, calling this function will
have no effect anyhow as only EGL is supported in this case.
Finally please note that the same effect can be achieved by setting the
environment variable `wx_opengl_egl=0` before starting the application.
@since 3.3.2
*/
static void PreferGLX();
/**
Sets the current colour for this window (using @c glcolor3f()), using
the wxWidgets colour database to find a named colour.

36
samples/opengl/cube/cube.cpp
View File

@@ -450,6 +450,7 @@ wxString glGetwxString(GLenum name)
wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_MENU(wxID_NEW, MyFrame::OnNewWindow)
EVT_MENU(NEW_STEREO_WINDOW, MyFrame::OnNewStereoWindow)
EVT_MENU(wxID_ABOUT, MyFrame::OnAbout)
EVT_MENU(wxID_CLOSE, MyFrame::OnClose)
wxEND_EVENT_TABLE()
@@ -465,6 +466,8 @@ MyFrame::MyFrame( bool stereoWindow )
menu->Append(wxID_NEW);
menu->Append(NEW_STEREO_WINDOW, "New Stereo Window");
menu->AppendSeparator();
menu->Append(wxID_ABOUT, "&About...\tF1");
menu->AppendSeparator();
menu->Append(wxID_CLOSE);
wxMenuBar *menuBar = new wxMenuBar;
menuBar->Append(menu, "&Cube");
@@ -492,6 +495,39 @@ MyFrame::MyFrame( bool stereoWindow )
}
}
void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
wxString info = "This is the wxWidgets OpenGL Cube sample.\n\n";
#ifdef wxHAS_GLX
const int glxVersion = wxGLCanvasUnix::GetGLXVersion();
if ( glxVersion == 0 )
{
info += "Using EGL.\n\n";
}
else
{
info += wxString::Format("Using GLX %d.%d.\n\n",
glxVersion / 10, glxVersion % 10);
}
#endif // wxHAS_GLX
auto const getString = [](GLenum name) -> wxString
{
const GLubyte* const str = glGetString(name);
return wxString::FromUTF8(reinterpret_cast<const char*>(str));
};
info += wxString::Format("OpenGL version: %s\n", getString(GL_VERSION));
info += wxString::Format("OpenGL vendor: %s\n", getString(GL_VENDOR));
info += wxString::Format("OpenGL renderer: %s", getString(GL_RENDERER));
wxMessageBox(info,
"About wxWidgets OpenGL cube sample",
wxOK | wxICON_INFORMATION,
this);
}
void MyFrame::OnClose(wxCommandEvent& WXUNUSED(event))
{
// true is to force the frame to close

1
samples/opengl/cube/cube.h
View File

@@ -54,6 +54,7 @@ public:
MyFrame(bool stereoWindow = false);
private:
void OnAbout(wxCommandEvent& event);
void OnClose(wxCommandEvent& event);
void OnNewWindow(wxCommandEvent& event);
void OnNewStereoWindow(wxCommandEvent& event);

5
setup.h.in
View File

@@ -506,8 +506,6 @@
#define wxUSE_GLCANVAS 0
#define wxUSE_GLCANVAS_EGL 0
#define wxUSE_RICHTEXT 0
@@ -1138,6 +1136,9 @@
/* Define if locale_t is available */
#undef HAVE_LOCALE_T
/* Define if you have EGL support */
#undef wxHAS_EGL
/* Define if you have inotify_xxx() functions. */
#undef wxHAS_INOTIFY

2
setup.h_vms
View File

@@ -553,8 +553,6 @@ typedef pid_t GPid;
#define wxUSE_GLCANVAS 1
#define wxUSE_GLCANVAS_EGL 0
#define wxUSE_RICHTEXT 1
#define wxUSE_CLIPBOARD 1

22
src/gtk/glcanvas.cpp
View File

@@ -42,7 +42,6 @@ static gboolean draw(GtkWidget* widget, cairo_t* cr, wxGLCanvas* win)
// emission hook for "parent-set"
//-----------------------------------------------------------------------------
#if !wxUSE_GLCANVAS_EGL
extern "C" {
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
@@ -70,7 +69,6 @@ parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void*
return true;
}
}
#endif
//---------------------------------------------------------------------------
// wxGlCanvas
@@ -111,12 +109,12 @@ static bool IsAvailable()
#ifdef GDK_WINDOWING_WAYLAND
if (wxGTKImpl::IsWayland(display))
{
#if wxUSE_GLCANVAS_EGL
#ifdef wxHAS_EGL
return true;
#else
wxSafeShowMessage(_("Fatal Error"), _("This program wasn't compiled with EGL support required under Wayland, either\ninstall EGL libraries and rebuild or run it under X11 backend by setting\nenvironment variable GDK_BACKEND=x11 before starting your program."));
return false;
#endif // wxUSE_GLCANVAS_EGL
#endif // wxHAS_EGL/!wxHAS_EGL
}
#endif // GDK_WINDOWING_WAYLAND
@@ -183,10 +181,11 @@ bool wxGLCanvas::Create(wxWindow *parent,
// watch for the "parent-set" signal on m_wxwindow so we can set colormap
// before m_wxwindow is realized (which will occur before
// wxWindow::Create() returns if parent is already visible)
#if !wxUSE_GLCANVAS_EGL
unsigned sig_id = g_signal_lookup("parent-set", GTK_TYPE_WIDGET);
g_signal_add_emission_hook(sig_id, 0, parent_set_hook, this, nullptr);
#endif
if ( GetGLXVersion() )
{
unsigned sig_id = g_signal_lookup("parent-set", GTK_TYPE_WIDGET);
g_signal_add_emission_hook(sig_id, 0, parent_set_hook, this, nullptr);
}
wxWindow::Create( parent, id, pos, size, style, name );
#ifdef __WXGTK3__
@@ -217,11 +216,10 @@ unsigned long wxGLCanvas::GetXWindow() const
void wxGLCanvas::GTKHandleRealized()
{
BaseType::GTKHandleRealized();
wxGLCanvasUnix::GTKHandleRealized();
CallOnRealized();
#if wxUSE_GLCANVAS_EGL
CreateSurface();
#endif
SendSizeEvent();
}

356
src/unix/glcanvas.cpp Normal file
View File

@@ -0,0 +1,356 @@
///////////////////////////////////////////////////////////////////////////////
// Name: src/unix/glcanvas.cpp
// Purpose: wxGLCanvas implementation common to wxGTK and wxX11
// Author: Vadim Zeitlin
// Created: 2025-12-07
// Copyright: (c) 2025 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/sysopt.h"
#include "wx/glcanvas.h"
#include "wx/unix/private/glcanvas.h"
#include "wx/unix/private/glx11.h"
#ifdef wxHAS_EGL
#include "wx/unix/private/glegl.h"
#ifdef __WXGTK3__
#include "wx/gtk/private/wrapgdk.h"
#include "wx/gtk/private/backend.h"
#endif // __WXGTK3__
#endif // wxHAS_EGL
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxGLContextAttrs: OpenGL rendering context attributes
// ----------------------------------------------------------------------------
wxGLContextAttrs& wxGLContextAttrs::CoreProfile()
{
return wxGLBackend::Get().CoreProfile(*this);
}
wxGLContextAttrs& wxGLContextAttrs::MajorVersion(int val)
{
return wxGLBackend::Get().MajorVersion(*this, val);
}
wxGLContextAttrs& wxGLContextAttrs::MinorVersion(int val)
{
return wxGLBackend::Get().MinorVersion(*this, val);
}
wxGLContextAttrs& wxGLContextAttrs::CompatibilityProfile()
{
return wxGLBackend::Get().CompatibilityProfile(*this);
}
wxGLContextAttrs& wxGLContextAttrs::ForwardCompatible()
{
return wxGLBackend::Get().ForwardCompatible(*this);
}
wxGLContextAttrs& wxGLContextAttrs::ES2()
{
return wxGLBackend::Get().ES2(*this);
}
wxGLContextAttrs& wxGLContextAttrs::DebugCtx()
{
return wxGLBackend::Get().DebugCtx(*this);
}
wxGLContextAttrs& wxGLContextAttrs::Robust()
{
return wxGLBackend::Get().Robust(*this);
}
wxGLContextAttrs& wxGLContextAttrs::NoResetNotify()
{
return wxGLBackend::Get().NoResetNotify(*this);
}
wxGLContextAttrs& wxGLContextAttrs::LoseOnReset()
{
return wxGLBackend::Get().LoseOnReset(*this);
}
wxGLContextAttrs& wxGLContextAttrs::ResetIsolation()
{
return wxGLBackend::Get().ResetIsolation(*this);
}
wxGLContextAttrs& wxGLContextAttrs::ReleaseFlush(int val)
{
return wxGLBackend::Get().ReleaseFlush(*this, val);
}
wxGLContextAttrs& wxGLContextAttrs::PlatformDefaults()
{
return wxGLBackend::Get().PlatformDefaults(*this);
}
void wxGLContextAttrs::EndList()
{
wxGLBackend::Get().EndList(*this);
}
// ----------------------------------------------------------------------------
// wxGLAttributes: Visual/FBconfig attributes
// ----------------------------------------------------------------------------
wxGLAttributes& wxGLAttributes::RGBA()
{
return wxGLBackend::Get().RGBA(*this);
}
wxGLAttributes& wxGLAttributes::BufferSize(int val)
{
return wxGLBackend::Get().BufferSize(*this, val);
}
wxGLAttributes& wxGLAttributes::Level(int val)
{
return wxGLBackend::Get().Level(*this, val);
}
wxGLAttributes& wxGLAttributes::DoubleBuffer()
{
return wxGLBackend::Get().DoubleBuffer(*this);
}
wxGLAttributes& wxGLAttributes::Stereo()
{
return wxGLBackend::Get().Stereo(*this);
}
wxGLAttributes& wxGLAttributes::AuxBuffers(int val)
{
return wxGLBackend::Get().AuxBuffers(*this, val);
}
wxGLAttributes& wxGLAttributes::MinRGBA(int mRed, int mGreen, int mBlue, int mAlpha)
{
return wxGLBackend::Get().MinRGBA(*this, mRed, mGreen, mBlue, mAlpha);
}
wxGLAttributes& wxGLAttributes::Depth(int val)
{
return wxGLBackend::Get().Depth(*this, val);
}
wxGLAttributes& wxGLAttributes::Stencil(int val)
{
return wxGLBackend::Get().Stencil(*this, val);
}
wxGLAttributes& wxGLAttributes::MinAcumRGBA(int mRed, int mGreen, int mBlue, int mAlpha)
{
return wxGLBackend::Get().MinAcumRGBA(*this, mRed, mGreen, mBlue, mAlpha);
}
wxGLAttributes& wxGLAttributes::SampleBuffers(int val)
{
return wxGLBackend::Get().SampleBuffers(*this, val);
}
wxGLAttributes& wxGLAttributes::Samplers(int val)
{
return wxGLBackend::Get().Samplers(*this, val);
}
wxGLAttributes& wxGLAttributes::FrameBuffersRGB()
{
return wxGLBackend::Get().FrameBuffersRGB(*this);
}
void wxGLAttributes::EndList()
{
wxGLBackend::Get().EndList(*this);
}
wxGLAttributes& wxGLAttributes::PlatformDefaults()
{
return wxGLBackend::Get().PlatformDefaults(*this);
}
// ----------------------------------------------------------------------------
// wxGLContext
// ----------------------------------------------------------------------------
wxIMPLEMENT_CLASS(wxGLContext, wxObject);
wxGLBackend* wxGLBackend::ms_instance = nullptr;
#ifdef wxHAS_EGL
static bool wxGLBackendPreferGLX = false;
/* static */
void wxGLBackend::PreferGLX()
{
wxASSERT_MSG( !ms_instance,
"PreferGLX() called too late and will have no effect" );
wxGLBackendPreferGLX = true;
}
#endif // wxHAS_EGL
/* static */
wxGLBackend* wxGLBackend::Init()
{
#ifdef wxHAS_EGL
// Only EGL can be used when using Wayland, so ignore calls to PreferGLX()
// and system option in that case.
//
// It is unfortunate that we need to call wxGTK-specific functions from
// this code which is shared by wxGTK and wxX11, but there is no way to
// virtualize it, notably we can't do it at wxGLCanvas level because it may
// be already too late: for example, the backend has to be already
// available for attributes creation.
#if defined(__WXGTK3__) && defined(GDK_WINDOWING_WAYLAND)
if ( wxGTKImpl::IsWayland(gdk_display_get_default()) )
return &wxGLBackendEGL::Get();
#endif // GTK 3 with Wayland
if ( !(wxGLBackendPreferGLX || wxSystemOptions::IsFalse("opengl.egl")) )
return &wxGLBackendEGL::Get();
#endif // wxHAS_EGL
return &wxGLBackendX11::Get();
}
wxGLContext::wxGLContext(wxGLCanvas *win,
const wxGLContext *other,
const wxGLContextAttrs *ctxAttrs)
: m_impl(wxGLBackend::Get().CreateContextImpl(win, other, ctxAttrs))
{
m_isOk = m_impl && m_impl->IsOK();
}
wxGLContext::~wxGLContext() = default;
bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
{
return IsOK() && m_impl->SetCurrent(win);
}
/* static */
void wxGLContextBase::ClearCurrent()
{
wxGLBackend::Get().ClearCurrentContext();
}
// ----------------------------------------------------------------------------
// wxGLCanvasUnix
// ----------------------------------------------------------------------------
wxGLCanvasUnix::wxGLCanvasUnix()
: m_impl(wxGLBackend::Get().CreateCanvasImpl(this))
{
}
wxGLCanvasUnix::~wxGLCanvasUnix() = default;
bool wxGLCanvasUnix::InitVisual(const wxGLAttributes& dispAttrs)
{
return m_impl->InitVisual(dispAttrs);
}
bool wxGLCanvasUnix::SwapBuffers()
{
return m_impl->SwapBuffers();
}
bool wxGLCanvasUnix::IsShownOnScreen() const
{
return m_impl->HasWindow() && wxGLCanvasBase::IsShownOnScreen();
}
void* wxGLCanvasUnix::GetXVisualInfo() const
{
return m_impl->GetXVisualInfo();
}
void wxGLCanvasUnix::CallOnRealized()
{
m_impl->OnRealized();
}
/* static */
void wxGLCanvasUnix::PreferGLX()
{
#ifdef wxHAS_EGL
wxGLBackend::PreferGLX();
#endif // wxHAS_EGL
}
/* static */
int wxGLCanvasUnix::GetGLXVersion()
{
return wxGLBackend::Get().GetGLXVersion();
}
/* static */
bool wxGLCanvasUnix::IsGLXMultiSampleAvailable()
{
return wxGLBackend::Get().IsGLXMultiSampleAvailable();
}
/* static */
bool wxGLCanvasBase::IsExtensionSupported(const char *extension)
{
return wxGLBackend::Get().IsExtensionSupported(extension);
}
/* static */
bool wxGLCanvasBase::IsDisplaySupported(const wxGLAttributes& dispAttrs)
{
return wxGLBackend::Get().IsDisplaySupported(dispAttrs);
}
/* static */
bool wxGLCanvasBase::IsDisplaySupported(const int *attribList)
{
wxGLAttributes dispAttrs;
ParseAttribList(attribList, dispAttrs);
return IsDisplaySupported(dispAttrs);
}
// ----------------------------------------------------------------------------
// wxGLApp
// ----------------------------------------------------------------------------
bool wxGLApp::InitGLVisual(const int* attribList)
{
return wxGLBackend::Get().InitDefaultVisualInfo(attribList);
}
void* wxGLApp::GetXVisualInfo()
{
return wxGLBackend::Get().GetDefaultVisualInfo();
}
int wxGLApp::OnExit()
{
wxGLBackend::Get().FreeDefaultVisualInfo();
return wxGLAppBase::OnExit();
}

373
src/unix/glegl.cpp
View File

File diff suppressed because it is too large Load Diff

398
src/unix/glx11.cpp
View File

File diff suppressed because it is too large Load Diff