Package ch.bailu.gtk.gtk

Class GLArea

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gobject.InitiallyUnowned
ch.bailu.gtk.gtk.Widget
ch.bailu.gtk.gtk.GLArea
All Implemented Interfaces:
PointerInterface
public class GLArea extends Widget
`GtkGLArea` is a widget that allows drawing with OpenGL.

![An example GtkGLArea](glarea.png)

`GtkGLArea` sets up its own [class@Gdk.GLContext], and creates a custom
GL framebuffer that the widget will do GL rendering onto. It also ensures
that this framebuffer is the default GL rendering target when rendering.

In order to draw, you have to connect to the [signal@Gtk.GLArea::render]
signal, or subclass `GtkGLArea` and override the GtkGLAreaClass.render
virtual function.

The `GtkGLArea` widget ensures that the `GdkGLContext` is associated with
the widget's drawing area, and it is kept updated when the size and
position of the drawing area changes.

## Drawing with GtkGLArea

The simplest way to draw using OpenGL commands in a `GtkGLArea` is to
create a widget instance and connect to the [signal@Gtk.GLArea::render] signal:

The `render()` function will be called when the `GtkGLArea` is ready
for you to draw its content:

```c
static gboolean
render (GtkGLArea *area, GdkGLContext *context)
{
// inside this function it's safe to use GL; the given
// GdkGLContext has been made current to the drawable
// surface used by the `GtkGLArea` and the viewport has
// already been set to be the size of the allocation

// we can start by clearing the buffer
glClearColor (0, 0, 0, 0);
glClear (GL_COLOR_BUFFER_BIT);

// draw your object
// draw_an_object ();

// we completed our drawing; the draw commands will be
// flushed at the end of the signal emission chain, and
// the buffers will be drawn on the window
return TRUE;
}

void setup_glarea (void)
{
// create a GtkGLArea instance
GtkWidget *gl_area = gtk_gl_area_new ();

// connect to the "render" signal
g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
}
```

If you need to initialize OpenGL state, e.g. buffer objects or
shaders, you should use the [signal@Gtk.Widget::realize] signal;
you can use the [signal@Gtk.Widget::unrealize] signal to clean up.
Since the `GdkGLContext` creation and initialization may fail, you
will need to check for errors, using [method@Gtk.GLArea.get_error].

An example of how to safely initialize the GL state is:

```c
static void
on_realize (GtkGLarea *area)
{
// We need to make the context current if we want to
// call GL API
gtk_gl_area_make_current (area);

// If there were errors during the initialization or
// when trying to make the context current, this
// function will return a GError for you to catch
if (gtk_gl_area_get_error (area) != NULL)
return;

// You can also use gtk_gl_area_set_error() in order
// to show eventual initialization errors on the
// GtkGLArea widget itself
GError *internal_error = NULL;
init_buffer_objects (&error);
if (error != NULL)
{
gtk_gl_area_set_error (area, error);
g_error_free (error);
return;
}

init_shaders (&error);
if (error != NULL)
{
gtk_gl_area_set_error (area, error);
g_error_free (error);
return;
}
}
```

If you need to change the options for creating the `GdkGLContext`
you should use the [signal@Gtk.GLArea::create-context] signal.

https://docs.gtk.org/gtk4/class.GLArea.html

  • Field Details

  • Constructor Details

    • GLArea

      public GLArea(PointerContainer pointer)

    • GLArea

      public GLArea()
      Creates a new `GtkGLArea` widget.

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • attachBuffers

      public void attachBuffers()
      Binds buffers to the framebuffer.

      Ensures that the @area framebuffer object is made the current draw
      and read target, and that all the required buffers for the @area
      are created and bound to the framebuffer.

      This function is automatically called before emitting the
      [signal@Gtk.GLArea::render] signal, and doesn't normally need to be
      called by application code.

    • getAutoRender

      public boolean getAutoRender()
      Returns whether the area is in auto render mode or not.
      Returns:
      %TRUE if the @area is auto rendering, %FALSE otherwise

    • getContext

      public GLContext getContext()
      Retrieves the `GdkGLContext` used by @area.
      Returns:
      the `GdkGLContext`

    • getError

      public Error getError()
      Gets the current error set on the @area.
      Returns:
      the `GError`

    • getHasDepthBuffer

      public boolean getHasDepthBuffer()
      Returns whether the area has a depth buffer.
      Returns:
      %TRUE if the @area has a depth buffer, %FALSE otherwise

    • getHasStencilBuffer

      public boolean getHasStencilBuffer()
      Returns whether the area has a stencil buffer.
      Returns:
      %TRUE if the @area has a stencil buffer, %FALSE otherwise

    • getRequiredVersion

      public void getRequiredVersion(@Nonnull Int major, @Nonnull Int minor)
      Retrieves the required version of OpenGL.

      See [method@Gtk.GLArea.set_required_version].
      Parameters:
      major - return location for the required major version
      minor - return location for the required minor version

    • getUseEs

      public boolean getUseEs()
      Returns whether the `GtkGLArea` should use OpenGL ES.

      See [method@Gtk.GLArea.set_use_es].
      Returns:
      %TRUE if the `GtkGLArea` should create an OpenGL ES context and %FALSE otherwise

    • makeCurrent

      public void makeCurrent()
      Ensures that the `GdkGLContext` used by @area is associated with
      the `GtkGLArea`.

      This function is automatically called before emitting the
      [signal@Gtk.GLArea::render] signal, and doesn't normally need
      to be called by application code.

    • queueRender

      public void queueRender()
      Marks the currently rendered data (if any) as invalid, and queues
      a redraw of the widget.

      This ensures that the [signal@Gtk.GLArea::render] signal
      is emitted during the draw.

      This is only needed when [method@Gtk.GLArea.set_auto_render] has
      been called with a %FALSE value. The default behaviour is to
      emit [signal@Gtk.GLArea::render] on each draw.

    • setAutoRender

      public void setAutoRender(boolean auto_render)
      Sets whether the `GtkGLArea` is in auto render mode.

      If @auto_render is %TRUE the [signal@Gtk.GLArea::render] signal will
      be emitted every time the widget draws. This is the default and is
      useful if drawing the widget is faster.

      If @auto_render is %FALSE the data from previous rendering is kept
      around and will be used for drawing the widget the next time,
      unless the window is resized. In order to force a rendering
      [method@Gtk.GLArea.queue_render] must be called. This mode is
      useful when the scene changes seldom, but takes a long time to redraw.
      Parameters:
      auto_render - a boolean

    • setError

      public void setError(@Nullable Error error)
      Sets an error on the area which will be shown instead of the
      GL rendering.

      This is useful in the [signal@Gtk.GLArea::create-context]
      signal if GL context creation fails.
      Parameters:
      error - a new `GError`, or %NULL to unset the error

    • setHasDepthBuffer

      public void setHasDepthBuffer(boolean has_depth_buffer)
      Sets whether the `GtkGLArea` should use a depth buffer.

      If @has_depth_buffer is %TRUE the widget will allocate and
      enable a depth buffer for the target framebuffer. Otherwise
      there will be none.
      Parameters:
      has_depth_buffer - %TRUE to add a depth buffer

    • setHasStencilBuffer

      public void setHasStencilBuffer(boolean has_stencil_buffer)
      Sets whether the `GtkGLArea` should use a stencil buffer.

      If @has_stencil_buffer is %TRUE the widget will allocate and
      enable a stencil buffer for the target framebuffer. Otherwise
      there will be none.
      Parameters:
      has_stencil_buffer - %TRUE to add a stencil buffer

    • setRequiredVersion

      public void setRequiredVersion(int major, int minor)
      Sets the required version of OpenGL to be used when creating
      the context for the widget.

      This function must be called before the area has been realized.
      Parameters:
      major - the major version
      minor - the minor version

    • setUseEs

      public void setUseEs(boolean use_es)
      Sets whether the @area should create an OpenGL or an OpenGL ES context.

      You should check the capabilities of the `GdkGLContext` before drawing
      with either API.
      Parameters:
      use_es - whether to use OpenGL or OpenGL ES

    • onCreateContext

      public SignalHandler onCreateContext(GLArea.OnCreateContext signal)
      Connect to signal "create-context".
      See GLArea.OnCreateContext.onCreateContext() for signal description.
      Field SIGNAL_ON_CREATE_CONTEXT contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onRender

      public SignalHandler onRender(GLArea.OnRender signal)
      Connect to signal "render".
      See GLArea.OnRender.onRender(ch.bailu.gtk.gdk.GLContext) for signal description.
      Field SIGNAL_ON_RENDER contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onResize

      public SignalHandler onResize(GLArea.OnResize signal)
      Connect to signal "resize".
      See GLArea.OnResize.onResize(int, int) for signal description.
      Field SIGNAL_ON_RESIZE contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • asAccessible

      public Accessible asAccessible()
      Implements interface Accessible. Call this to get access to interface functions.
      Overrides:
      asAccessible in class Widget
      Returns:
      Accessible

    • asBuildable

      public Buildable asBuildable()
      Implements interface Buildable. Call this to get access to interface functions.
      Overrides:
      asBuildable in class Widget
      Returns:
      Buildable

    • asConstraintTarget

      public ConstraintTarget asConstraintTarget()
      Implements interface ConstraintTarget. Call this to get access to interface functions.
      Overrides:
      asConstraintTarget in class Widget
      Returns:
      ConstraintTarget

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()