GLContext

Object Hierarchy:

Description:

[ CCode ( type_id = "gdk_gl_context_get_type ()" ) ]
public abstract class GLContext : DrawContext

`GdkGLContext` is an object representing a platform-specific OpenGL draw context.

`GdkGLContext`s are created for a surface using [method@Gdk.Surface.create_gl_context], and the context will match the characteristics of the surface.

A `GdkGLContext` is not tied to any particular normal framebuffer. For instance, it cannot draw to the surface 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 [func@cairo_draw_from_gl] 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 and 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 `GdkSurface`, which you typically get during the realize call of a widget.

A `GdkGLContext` is not realized until either [method@Gdk.GLContext.make_current] or [method@Gdk.GLContext.realize] is called. 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 [method@Gdk.Surface.create_gl_context] by calling [method@Gdk.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:

```c 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 [func@Gdk.GLContext.get_current]; you can also unset any `GdkGLContext` that is currently set by calling [func@Gdk.GLContext.clear_current].

Namespace: Gdk

Package: gtk4

Content:

Properties:

public GLAPI allowed_apis { get; set; }
The allowed APIs.
public GLAPI api { get; }
The API currently in use.
public GLContext shared_context { get; construct; }
Always null

Static methods:

public static void clear_current ()
Clears the current `GdkGLContext`.
public static unowned GLContext? get_current ()
Retrieves the current `GdkGLContext`.

Creation methods:

protected GLContext ()

Methods:

public GLAPI get_allowed_apis ()
Gets the allowed APIs set via set_allowed_apis.
public GLAPI get_api ()
Gets the API currently in use.
public bool get_debug_enabled ()
Retrieves whether the context is doing extra validations and runtime checking.
public unowned Display? get_display ()
Retrieves the display the this is created for
public bool get_forward_compatible ()
Retrieves whether the context is forward-compatible.
public void get_required_version (out int major, out int minor)
Retrieves required OpenGL version set as a requirement for the this realization.
public unowned GLContext? get_shared_context ()
Used to retrieves the `GdkGLContext` that this this share data with.
public unowned Surface? get_surface ()
Retrieves the surface used by the this.
public bool get_use_es ()
Checks whether the this is using an OpenGL or OpenGL ES profile.
public void get_version (out int major, out int minor)
Retrieves the OpenGL version of the this.
public bool is_legacy ()
Whether the `GdkGLContext` is in legacy mode or not.
public bool is_shared (GLContext other)
Checks if the two GL contexts can share resources.
public void make_current ()
Makes the this the current one.
public bool realize () throws Error
Realizes the given `GdkGLContext`.
public void set_allowed_apis (GLAPI apis)
Sets the allowed APIs.
public void set_debug_enabled (bool enabled)
Sets whether the `GdkGLContext` should perform extra validations and runtime checking.
public void set_forward_compatible (bool compatible)
Sets whether the `GdkGLContext` should be forward-compatible.
public void set_required_version (int major, int minor)
Sets the major and minor version of OpenGL to request.
public void set_use_es (int use_es)
Requests that GDK create an OpenGL ES context instead of an OpenGL one.

Inherited Members:

All known members inherited from class Gdk.DrawContext

All known members inherited from class GLib.Object