_glutils

This package provides utility functions to handle OpenGL resources.

The gl module provides a wrapper to OpenGL based on PyOpenGL.

_glutils.gl

This module loads PyOpenGL and provides a namespace for OpenGL.

getPlatform()

Returns the name of the PyOpenGL class handling the platform.

E.g., GLXPlatform, EGLPlatform

Return type:

Optional[str]

getVersion()

Returns the GL version as tuple of integers.

Return type:

tuple

Raises:

ValueError: If the version returned by the driver is not supported

testGL()

Test if required OpenGL version and extensions are available.

This MUST be run with an active OpenGL context.

Return type:

bool

enabled(capacity, enable=True)

Context manager enabling an OpenGL capacity.

This is not checking the current state of the capacity.

Parameters:

• capacity – The OpenGL capacity enum to enable/disable

• enable (bool) – True (default) to enable during context, False to disable

disabled(capacity, disable=True)

Context manager disabling an OpenGL capacity.

This is not checking the current state of the capacity.

Parameters:

• capacity – The OpenGL capacity enum to disable/enable

• disable (bool) – True (default) to disable during context, False to enable

glGetActiveAttrib(program, index)

Wrap PyOpenGL glGetActiveAttrib

Utility functions

For OpenGL context management:

getCurrent()

Returns platform dependent object of current OpenGL context.

This is useful to associate OpenGL resources with the context they are created in.

Returns:

Platform specific OpenGL context

setCurrent(context=<class 'silx.gui._glutils.Context._DEFAULT_CONTEXT'>)

Set a platform dependent OpenGL context

Parameters:

context – Platform dependent GL context

current(context)

Context manager setting the platform-dependent GL context

Parameters:

context – Platform dependent GL context

For type checking and conversion:

sizeofGLType(type_)

Returns the size in bytes of an element of type type_

isSupportedGLType(type_)

Test if a numpy type or dtype can be converted to a GL type.

numpyToGLType(type_)

Returns the GL type corresponding the provided numpy type or dtype.

Program

class Program(vertexShader, fragmentShader, attrib0='position')

Wrap OpenGL shader program.

The program is compiled lazily (i.e., at first program use()). When the program is compiled, it stores attributes and uniforms locations. So, attributes and uniforms must be used after use().

This object supports multiple OpenGL contexts.

Parameters:

• vertexShader (str) – The source of the vertex shader.

• fragmentShader (str) – The source of the fragment shader.

• attrib0 (str) – Attribute’s name to bind to position 0 (default: ‘position’). On certain platform, this attribute MUST be active and with an array attached to it in order for the rendering to occur….

property attributes

Vertex attributes names and locations as a dict of {str: int}.

WARNING: Read-only usage. To use only with a valid OpenGL context and after use() has been called for this context.

property uniforms

Program uniforms names and locations as a dict of {str: int}.

WARNING: Read-only usage. To use only with a valid OpenGL context and after use() has been called for this context.

property program

OpenGL id of the program.

WARNING: To use only with a valid OpenGL context and after use() has been called for this context.

use()

Make use of the program, compiling it if necessary

setUniformMatrix(name, value, transpose=True, safe=False)

Wrap glUniformMatrix[2|3|4]fv

Parameters:

• name (str) – The name of the uniform.

• value (numpy.ndarray with 2 or 3 dimensions of float32) – The 2D matrix (or the array of matrices, 3D). Matrices are 2x2, 3x3 or 4x4.

• transpose (bool) – Whether to transpose (True, default) or not.

• safe (bool) – False: raise an error if no uniform with this name; True: silently ignores it.

Raises:

KeyError – if no uniform corresponds to name.

Texture

class Texture(internalFormat, data=None, format_=None, shape=None, texUnit=0, minFilter=None, magFilter=None, wrap=None)

Base class to wrap OpenGL 2D and 3D texture

Parameters:

• internalFormat – OpenGL texture internal format

• data (numpy.ndarray or None) – The data to copy to the texture or None for an empty texture

• format – Input data format if different from internalFormat

• shape (List[int]) – If data is None, shape of the texture (height, width) or (depth, height, width)

• texUnit (int) – The texture unit to use

• minFilter – OpenGL texture minimization filter (default: GL_NEAREST)

• magFilter – OpenGL texture magnification filter (default: GL_LINEAR)

• wrap (OpenGL wrap mode or 2 or 3-tuple of wrap mode) – Texture wrap mode for dimensions: (t, s) or (r, t, s) If a single value is provided, it used for all dimensions.

property target

OpenGL target type of this texture

property ndim

The number of dimensions: 2 or 3

property internalFormat

Texture internal format

property shape

Shape of the texture: (height, width) or (depth, height, width)

property name

OpenGL texture name.

It is None if not initialized or already discarded.

property minFilter

Minifying function parameter (GL_TEXTURE_MIN_FILTER)

property magFilter

Magnification function parameter (GL_TEXTURE_MAG_FILTER)

prepare()

Synchronizes the OpenGL texture.

This method must be called with a current OpenGL context.

bind(texUnit=None)

Bind the texture to a texture unit.

The OpenGL texture is updated if needed.

This method must be called with a current OpenGL context.

Parameters:

texUnit (int) – The texture unit to use

discard()

Delete associated OpenGL texture.

This method must be called with a current OpenGL context.

update(format_, data, offset=(0, 0, 0), copy=True)

Update the content of the texture.

Texture is not resized, so data must fit into texture with the given offset.

This update is performed lazily during next call to prepare() or bind(). Data MUST not be changed until then.

Parameters:

• format – The OpenGL format of the data

• data – The data to use to update the texture

• offset (List[int]) – Offset in the texture where to copy the data

• copy (bool) – True (default) to copy data, False to use as is (do not modify)

FramebufferTexture

class FramebufferTexture(internalFormat, shape, stencilFormat=GL_DEPTH24_STENCIL8, depthFormat=GL_DEPTH24_STENCIL8, **kwargs)

Framebuffer with a texture.

Aimed at off-screen rendering to texture.

Parameters:

• internalFormat – OpenGL texture internal format

• shape (2-tuple of int) – Shape (height, width) of the framebuffer and texture

• stencilFormat – Stencil renderbuffer format

• depthFormat – Depth renderbuffer format

• kwargs – Extra arguments for Texture constructor

property shape

Shape of the framebuffer (height, width)

property texture

The texture this framebuffer is rendering to.

The life-cycle of the texture is managed by this object

property name

OpenGL name of the framebuffer

bind()

Bind this framebuffer for rendering

discard()

Delete associated OpenGL resources including texture

Vertex Buffer

class VertexBuffer(data=None, size=None, usage=None, target=None)

Object handling an OpenGL vertex buffer object

Parameters:

• data (numpy.ndarray or None) – Data used to fill the vertex buffer

• size (int) – Size in bytes of the buffer or None for data size

• usage – OpenGL vertex buffer expected usage pattern: GL_STREAM_DRAW, GL_STATIC_DRAW (default) or GL_DYNAMIC_DRAW

• target – Target buffer: GL_ARRAY_BUFFER (default) or GL_ELEMENT_ARRAY_BUFFER

property target

The target buffer of the vertex buffer

property usage

The expected usage of the vertex buffer

property name

OpenGL Vertex Buffer object name (int)

property size

Size in bytes of the Vertex Buffer Object (int)

bind()

Bind the vertex buffer

update(data, offset=0, size=None)

Update vertex buffer content.

Parameters:

• data (numpy.ndarray) – The data to put in the vertex buffer

• offset (int) – Offset in bytes in the buffer where to put the data

• size (int) – If provided, size of data to copy

discard()

Delete the vertex buffer

class VertexBufferAttrib(vbo, type_, size, dimension=1, offset=0, stride=0, normalization=False)

Describes data stored in a vertex buffer

Convenient class to store info for glVertexAttribPointer calls

Parameters:

• vbo (VertexBuffer) – The vertex buffer storing the data

• type (int) – The OpenGL type of the data

• size (int) – The number of data elements stored in the VBO

• dimension (int) – The number of type_ element(s) in [1, 4]

• offset (int) – Start offset of data in the vertex buffer

• stride (int) – Data stride in the vertex buffer

property itemsize

Size in bytes of a vertex buffer element (int)

property itemSize

Size in bytes of a vertex buffer element (int)

setVertexAttrib(attribute)

Call glVertexAttribPointer with objects information

vertexBuffer(arrays, prefix=None, suffix=None, usage=None)

Create a single vertex buffer from multiple 1D or 2D numpy arrays.

It is possible to reserve memory before and after each array in the VBO

Parameters:

• arrays (Iterable of numpy.ndarray) – Arrays of data to store

• prefix (Iterable of int or None) – If given, number of elements to reserve before each array

• suffix (Iterable of int or None) – If given, number of elements to reserve after each array

• usage (int) – vertex buffer expected usage or None for default

Returns:

List of VertexBufferAttrib objects sharing the same vertex buffer

font

Text rasterisation feature leveraging Qt font and text layout support.

getDefaultFontFamily()

Returns the default font family of the application

Return type:

str