Context
Context
- class arcade.gl.Context(window: pyglet.window.BaseWindow, gc_mode: str = 'context_gc')[source]
Bases:
object
Represents an OpenGL context. This context belongs to a
pyglet.Window
normally accessed throughwindow.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
orarcade.gl.BLEND
).- active: Optional[arcade.gl.context.Context] = 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
- CLAMP_TO_BORDER = 33069
- MIRRORED_REPEAT = 33648
- 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
Context.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
source + destination
- FUNC_SUBTRACT = 32778
Blend equations: source - destination
- FUNC_REVERSE_SUBTRACT = 32779
Blend equations: destination - source
- MIN = 32775
Blend equations: Minimum of source and destination
- MAX = 32776
Blend equations: 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 premultipled alpha:
SRC_ALPHA, ONE
- POINTS = 0
Primitive mode
- LINES = 1
Primitive mode
- LINE_LOOP = 2
Primitive mode
- LINE_STRIP = 3
Primitive mode
- TRIANGLES = 4
Primitive mode
- TRIANGLE_STRIP = 5
Primitive mode
- TRIANGLE_FAN = 6
Primitive mode
- LINES_ADJACENCY = 10
Primitive mode
- LINE_STRIP_ADJACENCY = 11
Primitive mode
- TRIANGLES_ADJACENCY = 12
Primitive mode
- TRIANGLE_STRIP_ADJACENCY = 13
Primitive mode
- PATCHES = 14
Patch mode (tessellation)
- objects: Deque[Any]
Collected objects to gc when gc_mode is “context_gc”. This can be used during debugging.
- property info: arcade.gl.context.Limits
Get the Limits object for this context containing information about hardware/driver limits and other context 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 limits: arcade.gl.context.Limits
Get the Limits object for this context containing information about hardware/driver limits and other context information.
Warning
This an old alias for
info
and is only around for backwards compatibility.Example:
>> ctx.limits.MAX_TEXTURE_SIZE (16384, 16384) >> ctx.limits.VENDOR NVIDIA Corporation >> ctx.limits.RENDERER NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2
- property stats: arcade.gl.context.ContextStats
Get the stats instance containing runtime information about creation and destruction of OpenGL objects.
Example:
>> ctx.limits.MAX_TEXTURE_SIZE (16384, 16384) >> ctx.limits.VENDOR NVIDIA Corporation >> ctx.limits.RENDERER NVIDIA GeForce RTX 2080 SUPER/PCIe/SSE2
- property window: pyglet.window.BaseWindow
The window this context belongs to.
- Type
pyglet.Window
- property screen: arcade.gl.framebuffer.Framebuffer
The framebuffer for the window.
- Type
Framebuffer
- property fbo: arcade.gl.framebuffer.Framebuffer
Get the currently active framebuffer. This property is read-only
- property gl_version: Tuple[int, int]
The OpenGL version as a 2 component tuple. This is the reported OpenGL version from drivers and might be a higher version than you requested.
- Type
tuple (major, minor) version
- gc() int [source]
Run garbage collection of OpenGL objects for this context. This is only needed when
gc_mode
iscontext_gc
.- Returns
The number of resources destroyed
- Return type
- 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: Optional[str]
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}")
- Type
- classmethod activate(ctx: arcade.gl.context.Context)[source]
Mark a context as the currently active one.
Warning
Never call this unless you know exactly what you are doing.
- enable(*flags)[source]
Enables one or more context flags:
# Single flag ctx.enable(ctx.BLEND) # Multiple flags ctx.enable(ctx.DEPTH_TEST, ctx.CULL_FACE)
- enable_only(*args)[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)
- 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)
- 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
- Type
tuple (x, y, width, height)
- property scissor: Optional[Tuple[int, int, int, int]]
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 toNone
.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
- Type
tuple (x, y, width, height)
- property blend_func: Tuple[int, int]
Get or set the blend function. This is tuple specifying how the red, green, blue, and alpha blending factors are computed for the source and destination pixel.
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 frompyglet.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
- Type
tuple (src, dst)
- 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.
- Type
- 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 togl_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.
- 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]
A suggestion to the driver to execute all the queued drawing calls even if the queue is not full yet. This is not a blocking call and only a suggestion. This can potentially be used for speedups when we don’t have anything else to render.
- copy_framebuffer(src: arcade.gl.framebuffer.Framebuffer, dst: arcade.gl.framebuffer.Framebuffer)[source]
Copies/blits a framebuffer to another one.
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 (Framebuffer) – The framebuffer to copy from
dst (Framebuffer) – The framebuffer we copy to
- buffer(*, data: Optional[Any] = None, reserve: int = 0, usage: str = 'static') arcade.gl.buffer.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
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.The available values means 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.
- framebuffer(*, color_attachments: Optional[Union[arcade.gl.texture.Texture, List[arcade.gl.texture.Texture]]] = None, depth_attachment: Optional[arcade.gl.texture.Texture] = None) arcade.gl.framebuffer.Framebuffer [source]
Create a Framebuffer.
- Parameters
color_attachments (List[arcade.gl.Texture]) – List of textures we want to render into
depth_attachment (arcade.gl.Texture) – Depth texture
- Return type
- texture(size: Tuple[int, int], *, components: int = 4, dtype: str = 'f1', data: Optional[Any] = None, wrap_x: Optional[ctypes.c_uint] = None, wrap_y: Optional[ctypes.c_uint] = None, filter: Optional[Tuple[ctypes.c_uint, ctypes.c_uint]] = None, samples: int = 0) arcade.gl.texture.Texture [source]
Create a 2D Texture.
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
components (int) – Number of components (1: R, 2: RG, 3: RGB, 4: RGBA)
dtype (str) – The data type of each component: f1, f2, f4 / i1, i2, i4 / u1, u2, u4
data (Any) – The texture data (optional). Can be bytes or an object supporting the buffer protocol.
wrap_x (GLenum) – How the texture wraps in x direction
wrap_y (GLenum) – How the texture wraps in y direction
filter (Tuple[GLenum,GLenum]) – Minification and magnification filter
samples (int) – Creates a multisampled texture for values > 0
- depth_texture(size: Tuple[int, int], *, data=None) arcade.gl.texture.Texture [source]
Create a 2D depth texture. Can be used as a depth attachment in a
Framebuffer
.
- geometry(content: Optional[Sequence[arcade.gl.types.BufferDescription]] = None, index_buffer: Optional[arcade.gl.buffer.Buffer] = None, mode: Optional[int] = None, index_element_size: int = 4)[source]
Create a Geomtry instance. This is Arcade’s version of a vertex array adding a lot of convenice 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 performace.
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 interlaved 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 (list) – List of
BufferDescription
(optional)index_buffer (Buffer) – Index/element buffer (optional)
mode (int) – The default draw mode (optional)
mode – The default draw mode (optional)
index_element_size (int) – Byte size of a single index/element in the index buffer. In other words, the index buffer can be 8, 16 or 32 bit integers. Can be 1, 2 or 4 (8, 16 or 32 bit unsigned integer)
- program(*, vertex_shader: str, fragment_shader: Optional[str] = None, geometry_shader: Optional[str] = None, tess_control_shader: Optional[str] = None, tess_evaluation_shader: Optional[str] = None, defines: Optional[Dict[str, str]] = None, varyings: Optional[Sequence[str]] = None, varyings_capture_mode: str = 'interleaved') arcade.gl.program.Program [source]
Create a
Program
given the vertex, fragment and geometry shader.- Parameters
vertex_shader (str) – vertex shader source
fragment_shader (str) – fragment shader source (optional)
geometry_shader (str) – geometry shader source (optional)
tess_control_shader (str) – tessellation control shader source (optional)
tess_evaluation_shader (str) – tessellation evaluation shader source (optional)
defines (dict) – Substitute #defines values in the source (optional)
varyings (Optional[Sequence[str]]) – 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 (str) – 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.
- Return type
- query(*, samples=True, time=True, primitives=True)[source]
Create a query object for measuring rendering calls in opengl.
- compute_shader(*, source: str) arcade.gl.compute_shader.ComputeShader [source]
Create a compute shader.
- Parameters
source (str) – The glsl source
ContextStats
- class arcade.gl.context.ContextStats(warn_threshold=100)[source]
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)
Limits
- class arcade.gl.context.Limits(ctx)[source]
OpenGL Limitations
- 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
- CONTEXT_PROFILE_MASK
A mask value indicating what context profile is used (core, compat etc.)
- 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_DUAL_SOURCE_DRAW_BUFFERS
Maximum number of active draw buffers when using dual-source blending
- 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_RECTANGLE_TEXTURE_SIZE
A rough estimate of the largest rectangular texture that the GL can handle
- MAX_RENDERBUFFER_SIZE
Maximum supported size for renderbuffers
- MAX_SAMPLE_MASK_WORDS
Maximum number of sample mask words
- MAX_TEXTURE_BUFFER_SIZE
Maximum number of texels allowed in the texel array of a texture buffer object
- 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_MAX_ANISOTROPY
The highest supported anisotropy value. Usually 8.0 or 16.0.
- MAX_VIEWPORT_DIMS
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: ctypes.c_uint, length: int)[source]
Get an enum as an int tuple
- get(enum: ctypes.c_uint) int [source]
Get an integer limit
- get_float(enum: ctypes.c_uint) float [source]
Get a float limit
- get_str(enum: ctypes.c_uint) str [source]
Get a string limit