gdk.glcontext

Module for [GLContext] class

class GLContext GLContextGidBuilder GLContextGidBuilderImpl

Types 3

classGLContext : gobject.object.ObjectWrap

#GdkGLContext is an object representing the platform-specific OpenGL drawing context.

#GdkGLContexts are created for a #GdkWindow using [gdk.window.Window.createGlContext], and the context will match the #GdkVisual of the window.

A #GdkGLContext is not tied to any particular normal framebuffer. For instance, it cannot draw to the #GdkWindow back buffer. The GDK repaint system is in full control of the painting to that. Instead, you can create render buffers or textures and use [gdk.global.cairoDrawFromGl] in the draw function of your widget to draw them. Then GDK will handle the integration of your rendering with that of other widgets.

Support for #GdkGLContext is platform-specific, context creation can fail, returning null context.

A #GdkGLContext has to be made "current" in order to start using it, otherwise any OpenGL call will be ignored.

Creating a new OpenGL context

In order to create a new #GdkGLContext instance you need a #GdkWindow, which you typically get during the realize call of a widget.

A #GdkGLContext is not realized until either [gdk.glcontext.GLContext.makeCurrent], or until it is realized using [gdk.glcontext.GLContext.realize]. It is possible to specify details of the GL context like the OpenGL version to be used, or whether the GL context should have extra state validation enabled after calling [gdk.window.Window.createGlContext] by calling [gdk.glcontext.GLContext.realize]. If the realization fails you have the option to change the settings of the #GdkGLContext and try again.

Using a GdkGLContext

You will need to make the #GdkGLContext the current context before issuing OpenGL calls; the system sends OpenGL commands to whichever context is current. It is possible to have multiple contexts, so you always need to ensure that the one which you want to draw with is the current one before issuing commands:

gdk_gl_context_make_current (context);

You can now perform your drawing using OpenGL commands.

You can check which #GdkGLContext is the current one by using [gdk.glcontext.GLContext.getCurrent]; you can also unset any #GdkGLContext that is currently set by calling [gdk.glcontext.GLContext.clearCurrent].

Methods
GType _getGType()
GType _gType() @property
GLContext self()Returns `this`, for use in `with` statements.
GLContextGidBuilder builder()Get builder for [gdk.glcontext.GLContext] Returns: New builder object
gdk.display.Display display() @propertyGet `display` property. Returns: The #GdkDisplay used to create the #GdkGLContext.
gdk.glcontext.GLContext sharedContext() @propertyGet `sharedContext` property. Returns: The #GdkGLContext that this context is sharing data with, or null
gdk.window.Window window() @propertyGet `window` property. Returns: The #GdkWindow the gl context is bound to.
void clearCurrent()Clears the current #GdkGLContext.
gdk.glcontext.GLContext getCurrent()Retrieves the current #GdkGLContext. Returns: the current #GdkGLContext, or null
bool getDebugEnabled()Retrieves the value set using [gdk.glcontext.GLContext.setDebugEnabled]. Returns: true if debugging is enabled
gdk.display.Display getDisplay()Retrieves the #GdkDisplay the context is created for Returns: a #GdkDisplay or null
bool getForwardCompatible()Retrieves the value set using [gdk.glcontext.GLContext.setForwardCompatible]. Returns: true if the context should be forward compatible
void getRequiredVersion(out int major, out int minor)Retrieves the major and minor version requested by calling [gdk.glcontext.GLContext.setRequiredVersion].
gdk.glcontext.GLContext getSharedContext()Retrieves the #GdkGLContext that this context share data with. Returns: a #GdkGLContext or null
bool getUseEs()Checks whether the context is using an OpenGL or OpenGL ES profile. Returns: true if the #GdkGLContext is using an OpenGL ES profile
void getVersion(out int major, out int minor)Retrieves the OpenGL version of the context.
gdk.window.Window getWindow()Retrieves the #GdkWindow used by the context. Returns: a #GdkWindow or null
bool isLegacy()Whether the #GdkGLContext is in legacy mode or not.
void makeCurrent()Makes the context the current one.
bool realize()Realizes the given #GdkGLContext.
void setDebugEnabled(bool enabled)Sets whether the #GdkGLContext should perform extra validations and run time checking. This is useful during development, but has additional overhead.
void setForwardCompatible(bool compatible)Sets whether the #GdkGLContext should be forward compatible.
void setRequiredVersion(int major, int minor)Sets the major and minor version of OpenGL to request.
void setUseEs(int useEs)Requests that GDK create a OpenGL ES context instead of an OpenGL one, if the platform and windowing system allows it.
Constructors
this(void * ptr, Flag!"Take" take)
classGLContextGidBuilderImpl(T) : gobject.object.ObjectWrapGidBuilderImpl!T
Methods
T display(gdk.display.Display propval)Set `display` property. Params: propval = The #GdkDisplay used to create the #GdkGLContext. Returns: Builder instance for fluent chaining
T sharedContext(gdk.glcontext.GLContext propval)Set `sharedContext` property. Params: propval = The #GdkGLContext that this context is sharing data with, or null Returns: Builder instance for fluent chaining
T window(gdk.window.Window propval)Set `window` property. Params: propval = The #GdkWindow the gl context is bound to. Returns: Builder instance for fluent chaining
classGLContextGidBuilder : GLContextGidBuilderImpl!GLContextGidBuilder

Fluent builder for [gdk.glcontext.GLContext]

Methods
GLContext build()