pyglet.gl

OpenGL interface.

This package imports all OpenGL and registered OpenGL extension functions. Functions have identical signatures to their C counterparts.

OpenGL is documented in full at the OpenGL Reference Pages.

The OpenGL Programming Guide, also known as “The Red Book”, is a popular reference manual organised by topic. It is available in digital and paper editions.

The following subpackages are imported into this “mega” package already (and so are available by importing pyglet.gl):

pyglet.gl.gl: OpenGL
pyglet.gl.gl.glext_arb: ARB registered OpenGL extension functions

These subpackages are also available, but are not imported into this namespace by default:

pyglet.gl.glext_nv: nVidia OpenGL extension functions
pyglet.gl.agl: AGL (Mac OS X OpenGL context functions)
pyglet.gl.glx: GLX (Linux OpenGL context functions)
pyglet.gl.glxext_arb: ARB registered GLX extension functions
pyglet.gl.glxext_nv: nvidia GLX extension functions
pyglet.gl.wgl: WGL (Windows OpenGL context functions)
pyglet.gl.wglext_arb: ARB registered WGL extension functions
pyglet.gl.wglext_nv: nvidia WGL extension functions

The information modules are provided for convenience, and are documented below.

exception ConfigException

exception ContextException

current_context = None

The active OpenGL context.

You can change the current context by calling Context.set_current; do not modify this global.

Type:: Context

New in version 1.1.

class GLException

__init__(*args, **kwargs)

__new__(**kwargs)

class ObjectSpace

__init__()

class Config

Graphics configuration.

A Config stores the preferences for OpenGL attributes such as the number of auxiliary buffers, size of the colour and depth buffers, double buffering, stencilling, multi- and super-sampling, and so on.

Different platforms support a different set of attributes, so these are set with a string key and a value which is integer or boolean.

__init__(**kwargs)

Create a template config with the given attributes.

Specify attributes as keyword arguments, for example:

template = Config(double_buffer=True)

create_context( share: Context | None, ) → Context

Create a GL context that satisifies this configuration.

Parameters:: share (Context | None) – If not None, a context with which to share objects with.
Deprecated:: Use CanvasConfig.create_context.
Return type:: Context

get_gl_attributes() → list[tuple[str, bool | int | str]]

Return a list of attributes set on this config

The attributes are returned as a list of tuples, containing the name and values. Any unset attributes will have a value of None.

Return type:: list[tuple[str, bool | int | str]]

is_complete() → bool

Determine if this config is complete and able to create a context.

Configs created directly are not complete, they can only serve as templates for retrieving a supported config from the system. For example, pyglet.window.Screen.get_matching_configs returns complete configs.

Deprecated:: Use isinstance(config, CanvasConfig).
Return type:: bool

match(canvas: Canvas) → list[pyglet.gl.base.CanvasConfig]

Return a list of matching complete configs for the given canvas.

Return type:: list[CanvasConfig]

accum_alpha_size: int: Bits per pixel devoted to the alpha component in the accumulation buffer.

accum_blue_size: int: Bits per pixel devoted to the blue component in the accumulation buffer.

accum_green_size: int: Bits per pixel devoted to the green component in the accumulation buffer.

accum_red_size: int: Bits per pixel devoted to the red component in the accumulation buffer.

alpha_size: int: Bits per sample per buffer devoted to the alpha component.

aux_buffers: int: The number of auxiliary color buffers.

blue_size: int: Bits per sample per buffer devoted to the blue component.

buffer_size: int: Total bits per sample per color buffer.

debug: bool: Debug mode.

depth_size: int: Bits per sample in the depth buffer.

double_buffer: bool: Specify the presence of a back-buffer for every color buffer.

forward_compatible: bool: Whether to use forward compatibility mode.

green_size: int: Bits per sample per buffer devoted to the green component.

major_version: int: The OpenGL major version.

minor_version: int: The OpenGL minor version.

opengl_api: str: The OpenGL API, such as “gl” or “gles”.

red_size: int: Bits per sample per buffer devoted to the red component.

sample_buffers: int: The number of multisample buffers.

samples: int: The number of samples per pixel, or 0 if there are no multisample buffers.

stencil_size: int: Bits per sample in the stencil buffer.

stereo: bool: Specify the presence of separate left and right buffer sets.

class CanvasConfig

Bases: Config

An OpenGL configuration for a particular canvas.

Use Config.match to obtain an instance of this class.

New in version 1.2.

__init__( canvas: Canvas, base_config: Config, )

Create a template config with the given attributes.

Specify attributes as keyword arguments, for example:

template = Config(double_buffer=True)

compatible(canvas: Canvas) → bool

Return type:: bool

create_context( share: Context, ) → Context

Create a GL context that satisifies this configuration.

Parameters:: share (Context) – If not None, a Context with which to share objects with.
Return type:: Context

is_complete() → bool

Determine if this config is complete and able to create a context.

Configs created directly are not complete, they can only serve as templates for retrieving a supported config from the system. For example, pyglet.window.Screen.get_matching_configs returns complete configs.

Deprecated:: Use isinstance(config, CanvasConfig).
Return type:: bool

canvas: Canvas: The canvas this config is valid on.

class Context

An OpenGL context for drawing.

Use CanvasConfig.create_context to create a context.

__init__( config: Config, context_share: Context | None = None, )

attach(canvas: Canvas)

create_program( *sources: tuple[str, str], ) → ShaderProgram

Create a ShaderProgram from OpenGL GLSL source.

This is a convenience method that takes one or more tuples of (source_string, shader_type), and returns a ShaderProgram instance.

source_string is OpenGL GLSL source code as a str, and shader_type is the OpenGL shader type, such as “vertex” or “fragment”. See Shader for more information. :rtype: ShaderProgram

Note

This method is cached. Given the same shader sources, the same ShaderProgram instance will be returned. For more control over the ShaderProgram lifecycle, it is recommended to manually create Shaders and link ShaderPrograms.

New in version 2.0.10.

delete_buffer(buffer_id: int) → None

Safely delete a Buffer belonging to this context’s object space.

This method behaves similarly to delete_texture, though for glDeleteBuffers instead of glDeleteTextures.

Return type:: None

delete_framebuffer(fbo_id: int) → None

Safely delete a Framebuffer Object belonging to this context.

This method behaves similarly to delete_vao, though for glDeleteFramebuffers instead of glDeleteVertexArrays.

Return type:: None

delete_renderbuffer(rbo_id: int) → None

Safely delete a Renderbuffer belonging to this context’s object space.

This method behaves similarly to delete_texture, though for glDeleteRenderbuffers instead of glDeleteTextures.

Return type:: None

delete_shader(shader_id: int) → None

Safely delete a Shader belonging to this context’s object space.

This method behaves similarly to delete_texture, though for glDeleteShader instead of glDeleteTextures.

Return type:: None

delete_shader_program(program_id: int) → None

Safely delete a ShaderProgram belonging to this context’s object space.

This method behaves similarly to delete_texture, though for glDeleteProgram instead of glDeleteTextures.

Return type:: None

delete_texture(texture_id: int) → None

Safely delete a Texture belonging to this context’s object space.

This method will delete the texture immediately via glDeleteTextures if the current context’s object space is the same as this context’s object space, and it is called from the main thread.

Otherwise, the texture will only be marked for deletion, postponing it until any context with the same object space becomes active again.

This makes it safe to call from anywhere, including other threads.

Return type:: None

delete_vao(vao_id: int) → None

Safely delete a Vertex Array Object belonging to this context.

If this context is not the current context or this method is not called from the main thread, its deletion will be postponed until this context is next made active again.

Otherwise, this method will immediately delete the VAO via glDeleteVertexArrays.

Return type:: None

destroy() → None

Release the Context.

The context will not be useable after being destroyed. Each platform has its own convention for releasing the context and the buffer(s) that depend on it in the correct order; this should never be called by an application.

Return type:: None

detach() → None

Return type:: None

get_info() → GLInfo

Get the GLInfo instance for this context.

Return type:: GLInfo

set_current() → None

Make this the active Context.

Setting the Context current will also delete any OpenGL objects that have been queued for deletion. IE: any objects that were created in this Context, but have been called for deletion while another Context was active.

Return type:: None

object_space: ObjectSpace: A container which is shared between all contexts that share GL objects.