Context

Context

class arcade.gl.Context(window: Window, gc_mode: str = 'context_gc', gl_api: str = 'gl')[source]

Bases:

Represents an OpenGL context. This context belongs to a pyglet window. normally accessed through window.ctx.

The Context class contains methods for creating resources, global states and commonly used enums. All enums also exist in the gl module. (ctx.BLEND or arcade.gl.BLEND).

Parameters:
  • window – The pyglet window this context belongs to

  • gc_mode – The garbage collection mode. Default is “context_gc”

  • gl_api – The OpenGL api. Default is “gl”

active: Context | None = None

The active context

NEAREST = 9728

Texture interpolation - Nearest pixel

LINEAR = 9729

Texture interpolation - Linear interpolate

NEAREST_MIPMAP_NEAREST = 9984

Texture interpolation - Minification filter for mipmaps

LINEAR_MIPMAP_NEAREST = 9985

Texture interpolation - Minification filter for mipmaps

NEAREST_MIPMAP_LINEAR = 9986

Texture interpolation - Minification filter for mipmaps

LINEAR_MIPMAP_LINEAR = 9987

Texture interpolation - Minification filter for mipmaps

REPEAT = 10497

Texture wrap mode - Repeat

CLAMP_TO_EDGE = 33071

Texture wrap mode - Clamp to border pixel

CLAMP_TO_BORDER = 33069

Texture wrap mode - Clamp to border color

MIRRORED_REPEAT = 33648

Texture wrap mode - Repeat mirrored

BLEND = 3042

Context flag - Blending

DEPTH_TEST = 2929

Context flag - Depth testing

CULL_FACE = 2884

Context flag - Face culling

PROGRAM_POINT_SIZE = 34370

Context flag - Enables gl_PointSize in vertex or geometry shaders.

When enabled we can write to gl_PointSize in the vertex shader to specify the point size for each individual point.

If this value is not set in the shader the behavior is undefined. This means the points may or may not appear depending if the drivers enforce some default value for gl_PointSize.

When disabled point_size is used.

ZERO = 0

Blend function

ONE = 1

Blend function

SRC_COLOR = 768

Blend function

ONE_MINUS_SRC_COLOR = 769

Blend function

SRC_ALPHA = 770

Blend function

ONE_MINUS_SRC_ALPHA = 771

Blend function

DST_ALPHA = 772

Blend function

ONE_MINUS_DST_ALPHA = 773

Blend function

DST_COLOR = 774

Blend function

ONE_MINUS_DST_COLOR = 775

Blend function

FUNC_ADD = 32774

Blend equation - source + destination

FUNC_SUBTRACT = 32778

Blend equation - source - destination

FUNC_REVERSE_SUBTRACT = 32779

Blend equation - destination - source

MIN = 32775

Blend equation - Minimum of source and destination

MAX = 32776

Blend equation - Maximum of source and destination

BLEND_DEFAULT = (770, 771)

Blend mode shortcut for default blend mode - SRC_ALPHA, ONE_MINUS_SRC_ALPHA

BLEND_ADDITIVE = (1, 1)

Blend mode shortcut for additive blending - ONE, ONE

BLEND_PREMULTIPLIED_ALPHA = (770, 1)

Blend mode shortcut for pre-multiplied alpha - SRC_ALPHA, ONE

POINTS = 0

Primitive mode - points

LINES = 1

Primitive mode - lines

LINE_LOOP = 2

Primitive mode - line loop

LINE_STRIP = 3

Primitive mode - line strip

TRIANGLES = 4

Primitive mode - triangles

TRIANGLE_STRIP = 5

Primitive mode - triangle strip

TRIANGLE_FAN = 6

Primitive mode - triangle fan

LINES_ADJACENCY = 10

Primitive mode - lines with adjacency

LINE_STRIP_ADJACENCY = 11

Primitive mode - line strip with adjacency

TRIANGLES_ADJACENCY = 12

Primitive mode - triangles with adjacency

TRIANGLE_STRIP_ADJACENCY = 13

Primitive mode - triangle strip with adjacency

PATCHES = 14

Primitive mode - Patch (tessellation)

gl_api: str = 'gl'

The OpenGL api. Usually “gl” or “gles”.

objects: Deque[Any]

Collected objects to gc when gc_mode is “context_gc”. This can be used during debugging.

property info: GLInfo

Get the info object for this context containing information about hardware/driver limits and other information.

Example:

>> ctx.info.MAX_TEXTURE_SIZE
(16384, 16384)
>> ctx.info.VENDOR
NVIDIA Corporation
>> ctx.info.RENDERER
NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2
property extensions: set[str]

Get a set of supported OpenGL extensions strings for this context.

This can be used to check if a specific extension is supported:

# Check if bindless textures are supported
"GL_ARB_bindless_texture" in ctx.extensions
# Check for multiple extensions
expected_extensions = {"GL_ARB_bindless_texture", "GL_ARB_get_program_binary"}
ctx.extensions & expected_extensions == expected_extensions
property stats: ContextStats

Get the stats instance containing runtime information about creation and destruction of OpenGL objects.

This can be useful for debugging and profiling. Creating and throwing away OpenGL objects can be detrimental to performance.

Example:

# Show the created and freed resource count
>> ctx.stats.texture
(100, 10)
>> ctx.framebuffer
(1, 0)
>> ctx.buffer
(10, 0)
property window: Window

The window this context belongs to (read only).

property screen: Framebuffer

The framebuffer for the window (read only)

property fbo: Framebuffer

Get the currently active framebuffer (read only).

property gl_version: Tuple[int, int]

The OpenGL major and minor version as a tuple.

This is the reported OpenGL version from drivers and might be a higher version than you requested.

gc() int[source]

Run garbage collection of OpenGL objects for this context. This is only needed when gc_mode is context_gc.

Returns:

The number of resources destroyed

property gc_mode: str

Set the garbage collection mode for OpenGL resources. Supported modes are:

# Default:
# Defer garbage collection until ctx.gc() is called
# This can be useful to enforce the main thread to
# run garbage collection of opengl resources
ctx.gc_mode = "context_gc"

# Auto collect is similar to python garbage collection.
# This is a risky mode. Know what you are doing before using this.
ctx.gc_mode = "auto"
property error: str | None

Check OpenGL error

Returns a string representation of the occurring error or None of no errors has occurred.

Example:

err = ctx.error
if err:
    raise RuntimeError("OpenGL error: {err}")
classmethod activate(ctx: Context)[source]

Mark a context as the currently active one.

Warning

Never call this unless you know exactly what you are doing.

Parameters:

ctx – The context to activate

enable(*flags: int)[source]

Enables one or more context flags:

# Single flag
ctx.enable(ctx.BLEND)
# Multiple flags
ctx.enable(ctx.DEPTH_TEST, ctx.CULL_FACE)
Parameters:

*flags – The flags to enable

enable_only(*args: int)[source]

Enable only some flags. This will disable all other flags. This is a simple way to ensure that context flag states are not lingering from other sections of your code base:

# Ensure all flags are disabled (enable no flags)
ctx.enable_only()
# Make sure only blending is enabled
ctx.enable_only(ctx.BLEND)
# Make sure only depth test and culling is enabled
ctx.enable_only(ctx.DEPTH_TEST, ctx.CULL_FACE)
Parameters:

*args – The flags to enable

enabled(*flags)[source]

Temporarily change enabled flags.

Flags that was enabled initially will stay enabled. Only new enabled flags will be reversed when exiting the context.

Example:

with ctx.enabled(ctx.BLEND, ctx.CULL_FACE):
    # Render something
enabled_only(*flags)[source]

Temporarily change enabled flags.

Only the supplied flags with be enabled in in the context. When exiting the context the old flags will be restored.

Example:

with ctx.enabled_only(ctx.BLEND, ctx.CULL_FACE):
    # Render something
disable(*args)[source]

Disable one or more context flags:

# Single flag
ctx.disable(ctx.BLEND)
# Multiple flags
ctx.disable(ctx.DEPTH_TEST, ctx.CULL_FACE)
is_enabled(flag) bool[source]

Check if a context flag is enabled.

Warning

This only tracks states set through this context instance. It does not query the actual OpenGL state. If you change context flags by calling glEnable or glDisable directly you are on your own.

property viewport: Tuple[int, int, int, int]

Get or set the viewport for the currently active framebuffer. The viewport simply describes what pixels of the screen OpenGL should render to. Normally it would be the size of the window’s framebuffer:

# 4:3 screen
ctx.viewport = 0, 0, 800, 600
# 1080p
ctx.viewport = 0, 0, 1920, 1080
# Using the current framebuffer size
ctx.viewport = 0, 0, *ctx.screen.size
property scissor: Tuple[int, int, int, int] | None

Get or set the scissor box for the active framebuffer. This is a shortcut for scissor().

By default the scissor box is disabled and has no effect and will have an initial value of None. The scissor box is enabled when setting a value and disabled when set to None.

Example:

# Set and enable scissor box only drawing
# in a 100 x 100 pixel lower left area
ctx.scissor = 0, 0, 100, 100
# Disable scissoring
ctx.scissor = None
property blend_func: Tuple[int, int] | Tuple[int, int, int, int]

Get or set the blend function. This is tuple specifying how the color and alpha blending factors are computed for the source and destination pixel.

When using a two component tuple you specify the blend function for the source and the destination.

When using a four component tuple you specify the blend function for the source color, source alpha destination color and destination alpha. (separate blend functions for color and alpha)

Supported blend functions are:

ZERO
ONE
SRC_COLOR
ONE_MINUS_SRC_COLOR
DST_COLOR
ONE_MINUS_DST_COLOR
SRC_ALPHA
ONE_MINUS_SRC_ALPHA
DST_ALPHA
ONE_MINUS_DST_ALPHA

# Shortcuts
DEFAULT_BLENDING     # (SRC_ALPHA, ONE_MINUS_SRC_ALPHA)
ADDITIVE_BLENDING    # (ONE, ONE)
PREMULTIPLIED_ALPHA  # (SRC_ALPHA, ONE)

These enums can be accessed in the arcade.gl module or simply as attributes of the context object. The raw enums from pyglet.gl can also be used.

Example:

# Using constants from the context object
ctx.blend_func = ctx.ONE, ctx.ONE
# from the gl module
from arcade import gl
ctx.blend_func = gl.ONE, gl.ONE
property front_face: str

Configure front face winding order of triangles.

By default the counter-clockwise winding side is the front face. This can be set set to clockwise or counter-clockwise:

ctx.front_face = "cw"
ctx.front_face = "ccw"
property cull_face: str

The face side to cull when face culling is enabled.

By default the back face is culled. This can be set to front, back or front_and_back:

ctx.cull_face = "front"
ctx.cull_face = "back"
ctx.cull_face = "front_and_back"
property wireframe: bool

Get or set the wireframe mode.

When enabled all primitives will be rendered as lines by changing the polygon mode.

property patch_vertices: int

Get or set number of vertices that will be used to make up a single patch primitive.

Patch primitives are consumed by the tessellation control shader (if present) and subsequently used for tessellation.

property point_size: float

Set or get the point size. Default is 1.0.

Point size changes the pixel size of rendered points. The min and max values are limited by POINT_SIZE_RANGE. This value usually at least (1, 100), but this depends on the drivers/vendors.

If variable point size is needed you can enable PROGRAM_POINT_SIZE and write to gl_PointSize in the vertex or geometry shader.

Note

Using a geometry shader to create triangle strips from points is often a safer way to render large points since you don’t have have any size restrictions and it offers more flexibility.

property primitive_restart_index: int

Get or set the primitive restart index. Default is -1.

The primitive restart index can be used in index buffers to restart a primitive. This is for example useful when you use triangle strips or line strips and want to start on a new strip in the same buffer / draw call.

finish() None[source]

Wait until all OpenGL rendering commands are completed.

This function will actually stall until all work is done and may have severe performance implications.

flush() None[source]

Flush the OpenGL command buffer.

This will send all queued commands to the GPU but will not wait until they are completed. This is useful when you want to ensure that all commands are sent to the GPU before doing something else.

copy_framebuffer(src: Framebuffer, dst: Framebuffer, src_attachment_index: int = 0, depth: bool = True)[source]

Copies/blits a framebuffer to another one. We can select one color attachment to copy plus an optional depth attachment.

This operation has many restrictions to ensure it works across different platforms and drivers:

  • The source and destination framebuffer must be the same size

  • The formats of the attachments must be the same

  • Only the source framebuffer can be multisampled

  • Framebuffers cannot have integer attachments

Parameters:
  • src – The framebuffer to copy from

  • dst – The framebuffer we copy to

  • src_attachment_index – The color attachment to copy from

  • depth – Also copy depth attachment if present

buffer(*, data: ByteString | memoryview | array | Array | None = None, reserve: int = 0, usage: str = 'static') Buffer[source]

Create an OpenGL Buffer object. The buffer will contain all zero-bytes if no data is supplied.

Examples:

# Create 1024 byte buffer
ctx.buffer(reserve=1024)
# Create a buffer with 1000 float values using python's array.array
from array import array
ctx.buffer(data=array('f', [i for in in range(1000)])
# Create a buffer with 1000 random 32 bit floats using numpy
self.ctx.buffer(data=np.random.random(1000).astype("f4"))

The data parameter can be anything that implements the Buffer Protocol.

This includes bytes, bytearray, array.array, and more. You may need to use typing workarounds for non-builtin types. See Writing Raw Bytes to GL Buffers & Textures for more information.

The usage parameter enables the GL implementation to make more intelligent decisions that may impact buffer object performance. It does not add any restrictions. If in doubt, skip this parameter and revisit when optimizing. The result are likely to be different between vendors/drivers or may not have any effect. Always use the default static usage for buffers that don’t change.

The available values mean the following:

stream
    The data contents will be modified once and used at most a few times.
static
    The data contents will be modified once and used many times.
dynamic
    The data contents will be modified repeatedly and used many times.
Parameters:
  • data – The buffer data. This can be a bytes instance or any any other object supporting the buffer protocol.

  • reserve – The number of bytes to reserve

  • usage – Buffer usage. ‘static’, ‘dynamic’ or ‘stream’

framebuffer(*, color_attachments: Texture2D | List[Texture2D] | None = None, depth_attachment: Texture2D | None = None) Framebuffer[source]

Create a Framebuffer.

Parameters:
  • color_attachments – List of textures we want to render into

  • depth_attachment – Depth texture

texture(size: Tuple[int, int], *, components: int = 4, dtype: str = 'f1', data: ByteString | memoryview | array | Array | None = None, wrap_x: int | None = None, wrap_y: int | None = None, filter: Tuple[int, int] | None = None, samples: int = 0, immutable: bool = False, internal_format: int | None = None, compressed: bool = False, compressed_data: bool = False) Texture2D[source]

Create a 2D Texture.

Example:

# Create a 1024 x 1024 RGBA texture
image = PIL.Image.open("my_texture.png")
ctx.texture(size=(1024, 1024), components=4, data=image.tobytes())

# Create and compress a texture. The compression format is set by the internal_format
image = PIL.Image.open("my_texture.png")
ctx.texture(
    size=(1024, 1024),
    components=4,
    compressed=True,
    internal_format=gl.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
    data=image.tobytes(),
)

# Create a compressed texture from raw compressed data. This is an extremely
# fast way to load a large number of textures.
image_bytes = "<raw compressed data from some source>"
ctx.texture(
    size=(1024, 1024),
    components=4,
    internal_format=gl.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
    compressed_data=True,
    data=image_bytes,
)

Wrap modes: GL_REPEAT, GL_MIRRORED_REPEAT, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER

Minifying filters: GL_NEAREST, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR

Magnifying filters: GL_NEAREST, GL_LINEAR

Parameters:
  • size – The size of the texture

  • components – Number of components (1: R, 2: RG, 3: RGB, 4: RGBA)

  • dtype – The data type of each component: f1, f2, f4 / i1, i2, i4 / u1, u2, u4

  • data – The texture data (optional). Can be bytes or any object supporting the buffer protocol.

  • wrap_x – How the texture wraps in x direction

  • wrap_y – How the texture wraps in y direction

  • filter – Minification and magnification filter

  • samples – Creates a multisampled texture for values > 0

  • immutable – Make the storage (not the contents) immutable. This can sometimes be required when using textures with compute shaders.

  • internal_format – The internal format of the texture. This can be used to enable sRGB or texture compression.

  • compressed – Set to True if you want the texture to be compressed. This assumes you have set a internal_format to a compressed format.

  • compressed_data – Set to True if you are passing in raw compressed pixel data. This implies compressed=True.

texture_array(size: Tuple[int, int, int], *, components: int = 4, dtype: str = 'f1', data: ByteString | memoryview | array | Array | None = None, wrap_x: int | None = None, wrap_y: int | None = None, filter: Tuple[int, int] | None = None) TextureArray[source]

Create a 2D Texture Array.

This is a 2D texture with multiple layers. This is useful for storing multiple textures in a single texture object. This can be used for texture atlases or storing multiple frames of an animation in a single texture or equally sized tile textures.

Note that size is a 3-tuple where the last value is the number of layers.

See texture() for arguments.

depth_texture(size: Tuple[int, int], *, data: ByteString | memoryview | array | Array | None = None) Texture2D[source]

Create a 2D depth texture. Can be used as a depth attachment in a Framebuffer.

Parameters:
  • size – The size of the texture

  • data (optional) – The texture data. Can be``bytes`` or any object supporting the buffer protocol.

sampler(texture: Texture2D) Sampler[source]

Create a sampler object for a texture.

Parameters:

texture – The texture to create a sampler for

geometry(content: Sequence[BufferDescription] | None = None, index_buffer: Buffer | None = None, mode: int | None = None, index_element_size: int = 4)[source]

Create a Geometry instance. This is Arcade’s version of a vertex array adding a lot of convenience for the user. Geometry objects are fairly light. They are mainly responsible for automatically map buffer inputs to your shader(s) and provide various methods for rendering or processing this geometry,

The same geometry can be rendered with different programs as long as your shader is using one or more of the input attribute. This means geometry with positions and colors can be rendered with a program only using the positions. We will automatically map what is necessary and cache these mappings internally for performance.

In short, the geometry object is a light object that describes what buffers contains and automatically negotiate with shaders/programs. This is a very complex field in OpenGL so the Geometry object provides substantial time savings and greatly reduces the complexity of your code.

Geometry also provide rendering methods supporting the following:

  • Rendering geometry with and without index buffer

  • Rendering your geometry using instancing. Per instance buffers can be provided or the current instance can be looked up using gl_InstanceID in shaders.

  • Running transform feedback shaders that writes to buffers instead the screen. This can write to one or multiple buffer.

  • Render your geometry with indirect rendering. This means packing multiple meshes into the same buffer(s) and batch drawing them.

Examples:

# Single buffer geometry with a vec2 vertex position attribute
ctx.geometry([BufferDescription(buffer, '2f', ["in_vert"])], mode=ctx.TRIANGLES)

# Single interleaved buffer with two attributes. A vec2 position and vec2 velocity
ctx.geometry([
        BufferDescription(buffer, '2f 2f', ["in_vert", "in_velocity"])
    ],
    mode=ctx.POINTS,
)

# Geometry with index buffer
ctx.geometry(
    [BufferDescription(buffer, '2f', ["in_vert"])],
    index_buffer=ibo,
    mode=ctx.TRIANGLES,
)

# Separate buffers
ctx.geometry([
        BufferDescription(buffer_pos, '2f', ["in_vert"])
        BufferDescription(buffer_vel, '2f', ["in_velocity"])
    ],
    mode=ctx.POINTS,
)

# Providing per-instance data for instancing
ctx.geometry([
        BufferDescription(buffer_pos, '2f', ["in_vert"])
        BufferDescription(buffer_instance_pos, '2f', ["in_offset"], instanced=True)
    ],
    mode=ctx.POINTS,
)
Parameters:
  • content (optional) – List of BufferDescription

  • index_buffer (optional) – Index/element buffer

  • mode (optional) – The default draw mode

  • mode – The default draw mode

  • index_element_size – Byte size of a single index/element in the index buffer. In other words, the index buffer can be 1, 2 or 4 byte integers. Can be 1, 2 or 4 (8, 16 or 32 bit unsigned integer)

program(*, vertex_shader: str, fragment_shader: str | None = None, geometry_shader: str | None = None, tess_control_shader: str | None = None, tess_evaluation_shader: str | None = None, common: List[str] | None = None, defines: Dict[str, str] | None = None, varyings: Sequence[str] | None = None, varyings_capture_mode: str = 'interleaved') Program[source]

Create a Program given shader sources and other settings.

Parameters:
  • vertex_shader – vertex shader source

  • fragment_shader (optional) – fragment shader source

  • geometry_shader (optional) – geometry shader source

  • tess_control_shader (optional) – tessellation control shader source

  • tess_evaluation_shader (optional) – tessellation evaluation shader source

  • common (optional) – Common shader sources injected into all shaders

  • defines (optional) – Substitute #defines values in the source

  • varyings (optional) – The name of the out attributes in a transform shader. This is normally not necessary since we auto detect them, but some more complex out structures we can’t detect.

  • varyings_capture_mode (optional) –

    The capture mode for transforms.

    • "interleaved" means all out attribute will be written to a single buffer.

    • "separate" means each out attribute will be written separate buffers.

    Based on these settings the transform() method will accept a single buffer or a list of buffer.

query(*, samples=True, time=True, primitives=True) Query[source]

Create a query object for measuring rendering calls in opengl.

Parameters:
  • samples – Collect written samples

  • time – Measure rendering duration

  • primitives – Collect the number of primitives emitted

compute_shader(*, source: str, common: Iterable[str] = ()) ComputeShader[source]

Create a compute shader.

Parameters:
  • source – The glsl source

  • common (optional) – Common / library source injected into compute shader

ContextStats

class arcade.gl.context.ContextStats(warn_threshold=100)[source]

Bases:

Runtime allocation statistics of OpenGL objects.

texture

Textures (created, freed)

framebuffer

Framebuffers (created, freed)

buffer

Buffers (created, freed)

program

Programs (created, freed)

vertex_array

Vertex Arrays (created, freed)

geometry

Geometry (created, freed)

compute_shader

Compute Shaders (created, freed)

query

Queries (created, freed)

incr(key: str) None[source]

Increments a counter.

Parameters:

key – The attribute name / counter to increment.

decr(key)[source]

Decrement a counter.

Parameters:

key – The attribute name / counter to decrement.

GLInfo

class arcade.gl.context.GLInfo(ctx)[source]

Bases:

OpenGL info and capabilities

MINOR_VERSION

Minor version number of the OpenGL API supported by the current context

MAJOR_VERSION

Major version number of the OpenGL API supported by the current context.

VENDOR

The vendor string. For example ‘NVIDIA Corporation’

RENDERER

The renderer things. For example “NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2

SAMPLE_BUFFERS

Value indicating the number of sample buffers associated with the framebuffer

SUBPIXEL_BITS

An estimate of the number of bits of subpixel resolution that are used to position rasterized geometry in window coordinates

UNIFORM_BUFFER_OFFSET_ALIGNMENT

Minimum required alignment for uniform buffer sizes and offset

MAX_ARRAY_TEXTURE_LAYERS

Value indicates the maximum number of layers allowed in an array texture, and must be at least 256

MAX_3D_TEXTURE_SIZE

A rough estimate of the largest 3D texture that the GL can handle. The value must be at least 64

MAX_COLOR_ATTACHMENTS

Maximum number of color attachments in a framebuffer

MAX_COLOR_TEXTURE_SAMPLES

Maximum number of samples in a color multisample texture

MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS

the number of words for fragment shader uniform variables in all uniform blocks

MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS

Number of words for geometry shader uniform variables in all uniform blocks

MAX_COMBINED_TEXTURE_IMAGE_UNITS

Maximum supported texture image units that can be used to access texture maps from the vertex shader

MAX_COMBINED_UNIFORM_BLOCKS

Maximum number of uniform blocks per program

MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS

Number of words for vertex shader uniform variables in all uniform blocks

MAX_CUBE_MAP_TEXTURE_SIZE

A rough estimate of the largest cube-map texture that the GL can handle

MAX_DEPTH_TEXTURE_SAMPLES

Maximum number of samples in a multisample depth or depth-stencil texture

MAX_DRAW_BUFFERS

Maximum number of simultaneous outputs that may be written in a fragment shader

MAX_ELEMENTS_INDICES

Recommended maximum number of vertex array indices

MAX_ELEMENTS_VERTICES

Recommended maximum number of vertex array vertices

MAX_FRAGMENT_INPUT_COMPONENTS

Maximum number of components of the inputs read by the fragment shader

MAX_FRAGMENT_UNIFORM_COMPONENTS

Maximum number of individual floating-point, integer, or boolean values that can be held in uniform variable storage for a fragment shader

MAX_FRAGMENT_UNIFORM_VECTORS

Maximum number of individual 4-vectors of floating-point, integer, or boolean values that can be held in uniform variable storage for a fragment shader

MAX_FRAGMENT_UNIFORM_BLOCKS

Maximum number of uniform blocks per fragment shader.

MAX_GEOMETRY_INPUT_COMPONENTS

Maximum number of components of inputs read by a geometry shader

MAX_GEOMETRY_OUTPUT_COMPONENTS

Maximum number of components of outputs written by a geometry shader

MAX_GEOMETRY_TEXTURE_IMAGE_UNITS

Maximum supported texture image units that can be used to access texture maps from the geometry shader

MAX_GEOMETRY_UNIFORM_BLOCKS

Maximum number of uniform blocks per geometry shader

MAX_GEOMETRY_UNIFORM_COMPONENTS

Maximum number of individual floating-point, integer, or boolean values that can be held in uniform variable storage for a geometry shader

MAX_INTEGER_SAMPLES

Maximum number of samples supported in integer format multisample buffers

MAX_SAMPLES

Maximum samples for a framebuffer

MAX_RENDERBUFFER_SIZE

Maximum supported size for renderbuffers

MAX_SAMPLE_MASK_WORDS

Maximum number of sample mask words

MAX_TEXTURE_SIZE

The value gives a rough estimate of the largest texture that the GL can handle

MAX_UNIFORM_BUFFER_BINDINGS

Maximum number of uniform buffer binding points on the context

MAX_UNIFORM_BLOCK_SIZE

Maximum size in basic machine units of a uniform block

MAX_VARYING_VECTORS

The number 4-vectors for varying variables

MAX_VERTEX_ATTRIBS

Maximum number of 4-component generic vertex attributes accessible to a vertex shader.

MAX_VERTEX_TEXTURE_IMAGE_UNITS

Maximum supported texture image units that can be used to access texture maps from the vertex shader.

MAX_VERTEX_UNIFORM_COMPONENTS

Maximum number of individual floating-point, integer, or boolean values that can be held in uniform variable storage for a vertex shader

MAX_VERTEX_UNIFORM_VECTORS

Maximum number of 4-vectors that may be held in uniform variable storage for the vertex shader

MAX_VERTEX_OUTPUT_COMPONENTS

Maximum number of components of output written by a vertex shader

MAX_VERTEX_UNIFORM_BLOCKS

Maximum number of uniform blocks per vertex shader.

MAX_TEXTURE_IMAGE_UNITS

Number of texture units

MAX_TEXTURE_MAX_ANISOTROPY

The highest supported anisotropy value. Usually 8.0 or 16.0.

MAX_VIEWPORT_DIMS: Tuple[int, int]

The maximum support window or framebuffer viewport. This is usually the same as the maximum texture size

MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS

How many buffers we can have as output when doing a transform(feedback). This is usually 4.

POINT_SIZE_RANGE

The minimum and maximum point size

get_int_tuple(enum: c_uint | int, length: Literal[2]) Tuple[int, int][source]
get_int_tuple(enum: c_uint | int, length: int) Tuple[int, ...]

Get an enum as an int tuple

Parameters:
  • enum – The enum to query

  • length – The length of the tuple

get(enum: c_uint | int, default=0) int[source]

Get an integer limit.

Parameters:
  • enum – The enum to query

  • default – The default value if the query fails

get_float(enum: c_uint | int, default=0.0) float[source]

Get a float limit

Parameters:
  • enum – The enum to query

  • default – The default value if the query fails

get_str(enum: c_uint | int) str[source]

Get a string limit.

Parameters:

enum – The enum to query