from ctypes import * from weakref import proxy import pyglet from pyglet.graphics.vertexbuffer import BufferObject from pyglet.gl import * _debug_gl_shaders = pyglet.options['debug_gl_shaders'] class ShaderException(BaseException): pass _c_types = { GL_BYTE: c_byte, GL_UNSIGNED_BYTE: c_ubyte, GL_SHORT: c_short, GL_UNSIGNED_SHORT: c_ushort, GL_INT: c_int, GL_UNSIGNED_INT: c_uint, GL_FLOAT: c_float, GL_DOUBLE: c_double, } # TODO: test other shader types, and update if necessary. _shader_types = { 'vertex': GL_VERTEX_SHADER, 'geometry': GL_GEOMETRY_SHADER, 'fragment': GL_FRAGMENT_SHADER, } _uniform_getters = { GLint: glGetUniformiv, GLfloat: glGetUniformfv, GLboolean: glGetUniformiv, } _uniform_setters = { # uniform: gl_type, legacy_setter, setter, length, count GL_BOOL: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_BOOL_VEC2: (GLint, glUniform1iv, glProgramUniform1iv, 2, 1), GL_BOOL_VEC3: (GLint, glUniform1iv, glProgramUniform1iv, 3, 1), GL_BOOL_VEC4: (GLint, glUniform1iv, glProgramUniform1iv, 4, 1), GL_INT: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_INT_VEC2: (GLint, glUniform2iv, glProgramUniform2iv, 2, 1), GL_INT_VEC3: (GLint, glUniform3iv, glProgramUniform3iv, 3, 1), GL_INT_VEC4: (GLint, glUniform4iv, glProgramUniform4iv, 4, 1), GL_FLOAT: (GLfloat, glUniform1fv, glProgramUniform1fv, 1, 1), GL_FLOAT_VEC2: (GLfloat, glUniform2fv, glProgramUniform2fv, 2, 1), GL_FLOAT_VEC3: (GLfloat, glUniform3fv, glProgramUniform3fv, 3, 1), GL_FLOAT_VEC4: (GLfloat, glUniform4fv, glProgramUniform4fv, 4, 1), GL_SAMPLER_1D: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_SAMPLER_2D: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_SAMPLER_2D_ARRAY: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_SAMPLER_3D: (GLint, glUniform1iv, glProgramUniform1iv, 1, 1), GL_FLOAT_MAT2: (GLfloat, glUniformMatrix2fv, glProgramUniformMatrix2fv, 4, 1), GL_FLOAT_MAT3: (GLfloat, glUniformMatrix3fv, glProgramUniformMatrix3fv, 6, 1), GL_FLOAT_MAT4: (GLfloat, glUniformMatrix4fv, glProgramUniformMatrix4fv, 16, 1), # TODO: test/implement these: # GL_FLOAT_MAT2x3: glUniformMatrix2x3fv, glProgramUniformMatrix2x3fv, # GL_FLOAT_MAT2x4: glUniformMatrix2x4fv, glProgramUniformMatrix2x4fv, # GL_FLOAT_MAT3x2: glUniformMatrix3x2fv, glProgramUniformMatrix3x2fv, # GL_FLOAT_MAT3x4: glUniformMatrix3x4fv, glProgramUniformMatrix3x4fv, # GL_FLOAT_MAT4x2: glUniformMatrix4x2fv, glProgramUniformMatrix4x2fv, # GL_FLOAT_MAT4x3: glUniformMatrix4x3fv, glProgramUniformMatrix4x3fv, } _attribute_types = { GL_BOOL: (1, '?'), GL_BOOL_VEC2: (2, '?'), GL_BOOL_VEC3: (3, '?'), GL_BOOL_VEC4: (4, '?'), GL_INT: (1, 'i'), GL_INT_VEC2: (2, 'i'), GL_INT_VEC3: (3, 'i'), GL_INT_VEC4: (4, 'i'), GL_UNSIGNED_INT: (1, 'I'), GL_UNSIGNED_INT_VEC2: (2, 'I'), GL_UNSIGNED_INT_VEC3: (3, 'I'), GL_UNSIGNED_INT_VEC4: (4, 'I'), GL_FLOAT: (1, 'f'), GL_FLOAT_VEC2: (2, 'f'), GL_FLOAT_VEC3: (3, 'f'), GL_FLOAT_VEC4: (4, 'f'), GL_DOUBLE: (1, 'd'), GL_DOUBLE_VEC2: (2, 'd'), GL_DOUBLE_VEC3: (3, 'd'), GL_DOUBLE_VEC4: (4, 'd'), } class Attribute: """Abstract accessor for an attribute in a mapped buffer.""" def __init__(self, name, location, count, gl_type, normalize): """Create the attribute accessor. :Parameters: `name` : str Name of the vertex attribute. `location` : int Location (index) of the vertex attribute. `count` : int Number of components in the attribute. `gl_type` : int OpenGL type enumerant; for example, ``GL_FLOAT`` `normalize`: bool True if OpenGL should normalize the values """ self.name = name self.location = location self.count = count self.gl_type = gl_type self.c_type = _c_types[gl_type] self.normalize = normalize self.align = sizeof(self.c_type) self.size = count * self.align self.stride = self.size def enable(self): """Enable the attribute.""" glEnableVertexAttribArray(self.location) def set_pointer(self, ptr): """Setup this attribute to point to the currently bound buffer at the given offset. ``offset`` should be based on the currently bound buffer's ``ptr`` member. :Parameters: `offset` : int Pointer offset to the currently bound buffer for this attribute. """ glVertexAttribPointer(self.location, self.count, self.gl_type, self.normalize, self.stride, ptr) def get_region(self, buffer, start, count): """Map a buffer region using this attribute as an accessor. The returned region consists of a contiguous array of component data elements. For example, if this attribute uses 3 floats per vertex, and the `count` parameter is 4, the number of floats mapped will be ``3 * 4 = 12``. :Parameters: `buffer` : `AbstractMappable` The buffer to map. `start` : int Offset of the first vertex to map. `count` : int Number of vertices to map :rtype: `AbstractBufferRegion` """ byte_start = self.stride * start byte_size = self.stride * count array_count = self.count * count ptr_type = POINTER(self.c_type * array_count) return buffer.get_region(byte_start, byte_size, ptr_type) def set_region(self, buffer, start, count, data): """Set the data over a region of the buffer. :Parameters: `buffer` : AbstractMappable` The buffer to modify. `start` : int Offset of the first vertex to set. `count` : int Number of vertices to set. `data` : A sequence of data components. """ byte_start = self.stride * start byte_size = self.stride * count array_count = self.count * count data = (self.c_type * array_count)(*data) buffer.set_data_region(data, byte_start, byte_size) def __repr__(self): return f"Attribute(name='{self.name}', location={self.location}, count={self.count})" class _Uniform: __slots__ = 'program', 'name', 'type', 'location', 'length', 'count', 'get', 'set' def __init__(self, program, name, uniform_type, location, dsa): self.program = program self.name = name self.type = uniform_type self.location = location gl_type, gl_setter_legacy, gl_setter_dsa, length, count = _uniform_setters[uniform_type] gl_setter = gl_setter_dsa if dsa else gl_setter_legacy gl_getter = _uniform_getters[gl_type] self.length = length self.count = count is_matrix = uniform_type in (GL_FLOAT_MAT2, GL_FLOAT_MAT2x3, GL_FLOAT_MAT2x4, GL_FLOAT_MAT3, GL_FLOAT_MAT3x2, GL_FLOAT_MAT3x4, GL_FLOAT_MAT4, GL_FLOAT_MAT4x2, GL_FLOAT_MAT4x3) c_array = (gl_type * length)() ptr = cast(c_array, POINTER(gl_type)) self.get = self._create_getter_func(program, location, gl_getter, c_array, length) self.set = self._create_setter_func(program, location, gl_setter, c_array, length, count, ptr, is_matrix, dsa) @staticmethod def _create_getter_func(program, location, gl_getter, c_array, length): """Factory function for creating simplified Uniform getters""" if length == 1: def getter_func(): gl_getter(program, location, c_array) return c_array[0] else: def getter_func(): gl_getter(program, location, c_array) return c_array[:] return getter_func @staticmethod def _create_setter_func(program, location, gl_setter, c_array, length, count, ptr, is_matrix, dsa): """Factory function for creating simplified Uniform setters""" if dsa: # Bindless updates: if is_matrix: def setter_func(value): c_array[:] = value gl_setter(program, location, count, GL_FALSE, ptr) elif length == 1 and count == 1: def setter_func(value): c_array[0] = value gl_setter(program, location, count, ptr) elif length > 1 and count == 1: def setter_func(values): c_array[:] = values gl_setter(program, location, count, ptr) else: raise NotImplementedError("Uniform type not yet supported.") return setter_func else: if is_matrix: def setter_func(value): glUseProgram(program) c_array[:] = value gl_setter(location, count, GL_FALSE, ptr) elif length == 1 and count == 1: def setter_func(value): glUseProgram(program) c_array[0] = value gl_setter(location, count, ptr) elif length > 1 and count == 1: def setter_func(values): glUseProgram(program) c_array[:] = values gl_setter(location, count, ptr) else: raise NotImplementedError("Uniform type not yet supported.") return setter_func def __repr__(self): return f"Uniform('{self.name}', location={self.location}, length={self.length}, count={self.count})" class ShaderSource: """GLSL source container for making source parsing simpler. We support locating out attributes and applying #defines values. NOTE: We do assume the source is neat enough to be parsed this way and don't contain several statements in one line. """ def __init__(self, source: str, source_type: gl.GLenum): """Create a shader source wrapper.""" self._lines = source.strip().splitlines() self._type = source_type if not self._lines: raise ValueError("Shader source is empty") self._version = self._find_glsl_version() if pyglet.gl.current_context.get_info().get_opengl_api() == "gles": self._lines[0] = "#version 310 es" self._lines.insert(1, "precision mediump float;") if self._type == gl.GL_GEOMETRY_SHADER: self._lines.insert(1, "#extension GL_EXT_geometry_shader : require") if self._type == gl.GL_COMPUTE_SHADER: self._lines.insert(1, "precision mediump image2D;") self._version = self._find_glsl_version() def validate(self) -> str: """Return the validated shader source.""" return "\n".join(self._lines) def _find_glsl_version(self) -> int: if self._lines[0].strip().startswith("#version"): try: return int(self._lines[0].split()[1]) except Exception: pass source = "\n".join(f"{str(i+1).zfill(3)}: {line} " for i, line in enumerate(self._lines)) raise ShaderException(("Cannot find #version flag in shader source. " "A #version statement is required on the first line.\n" "------------------------------------\n" f"{source}")) class Shader: """OpenGL Shader object""" def __init__(self, source_string, shader_type): """Create an instance of a Shader object. Shader objects are compiled on instantiation. You can reuse a Shader object in multiple `ShaderProgram`s. :Parameters: `source_string` : str A string containing the Shader source code. `shader_type` : str The Shader type, such as "vertex", "fragment", "geometry", etc. """ self._id = None if shader_type not in _shader_types: raise TypeError("The `shader_type` '{}' is not yet supported".format(shader_type)) self.type = shader_type source_string = ShaderSource(source_string, _shader_types[shader_type]).validate() shader_source_utf8 = source_string.encode("utf8") source_buffer_pointer = cast(c_char_p(shader_source_utf8), POINTER(c_char)) source_length = c_int(len(shader_source_utf8)) shader_id = glCreateShader(_shader_types[shader_type]) glShaderSource(shader_id, 1, byref(source_buffer_pointer), source_length) glCompileShader(shader_id) status = c_int(0) glGetShaderiv(shader_id, GL_COMPILE_STATUS, byref(status)) if status.value != GL_TRUE: source = self._get_shader_source(shader_id) source_lines = "{0}".format("\n".join(f"{str(i+1).zfill(3)}: {line} " for i, line in enumerate(source.split("\n")))) raise GLException( ( f"The {self.type} shader failed to compile.\n" f"{self._get_shader_log(shader_id)}" "------------------------------------------------------------\n" f"{source_lines}\n" "------------------------------------------------------------" ) ) elif _debug_gl_shaders: print(self._get_shader_log(shader_id)) self._id = shader_id @property def id(self): return self._id def _get_shader_log(self, shader_id): log_length = c_int(0) glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, byref(log_length)) result_str = create_string_buffer(log_length.value) glGetShaderInfoLog(shader_id, log_length, None, result_str) if result_str.value: return ("OpenGL returned the following message when compiling the {0} shader: " "\n{1}".format(self.type, result_str.value.decode('utf8'))) else: return f"{self.type.capitalize()} Shader '{shader_id}' compiled successfully." @staticmethod def _get_shader_source(shader_id): """Get the shader source from the shader object""" source_length = c_int(0) glGetShaderiv(shader_id, GL_SHADER_SOURCE_LENGTH, source_length) source_str = create_string_buffer(source_length.value) glGetShaderSource(shader_id, source_length, None, source_str) return source_str.value.decode('utf8') def __del__(self): try: glDeleteShader(self._id) if _debug_gl_shaders: print(f"Destroyed {self.type} Shader '{self._id}'") except Exception: # Interpreter is shutting down, # or Shader failed to compile. pass def __repr__(self): return "{0}(id={1}, type={2})".format(self.__class__.__name__, self.id, self.type) class ShaderProgram: """OpenGL Shader Program""" __slots__ = '_id', '_context', '_attributes', '_uniforms', '_uniform_blocks', '__weakref__', '_dsa' def __init__(self, *shaders): """Create an OpenGL ShaderProgram, from multiple Shaders. Link multiple Shader objects together into a ShaderProgram. :Parameters: `shaders` : `Shader` One or more Shader objects """ assert shaders, "At least one Shader object is required." self._id = self._link_program(shaders) if _debug_gl_shaders: print(self._get_program_log()) self._context = pyglet.gl.current_context # Query if Direct State Access is available: self._dsa = gl_info.have_version(4, 1) or gl_info.have_extension("GL_ARB_separate_shader_objects") self._attributes = self._introspect_attributes() self._uniforms = self._introspect_uniforms() self._uniform_blocks = self._introspect_uniform_blocks() @property def id(self): return self._id @property def attributes(self): return self._attributes @property def uniforms(self): return self._uniforms @property def uniform_blocks(self): return self._uniform_blocks def _get_program_log(self): result = c_int(0) glGetProgramiv(self._id, GL_INFO_LOG_LENGTH, byref(result)) result_str = create_string_buffer(result.value) glGetProgramInfoLog(self._id, result, None, result_str) if result_str.value: return f"OpenGL returned the following message when linking the program: \n{result_str.value}" else: return f"Program '{self._id}' linked successfully." @staticmethod def _link_program(shaders): program_id = glCreateProgram() for shader in shaders: glAttachShader(program_id, shader.id) glLinkProgram(program_id) # Check the link status of program status = c_int() glGetProgramiv(program_id, GL_LINK_STATUS, status) if not status.value: length = c_int() glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, length) log = c_buffer(length.value) glGetProgramInfoLog(program_id, len(log), None, log) raise ShaderException("Error linking shader program:\n{}".format(log.value.decode())) # Shader objects no longer needed for shader in shaders: glDetachShader(program_id, shader.id) return program_id def use(self): glUseProgram(self._id) def stop(self): glUseProgram(0) __enter__ = use bind = use unbind = stop def __exit__(self, *_): glUseProgram(0) def __del__(self): try: self._context.delete_shader_program(self.id) except Exception: # Interpreter is shutting down, # or ShaderProgram failed to link. pass def __setitem__(self, key, value): try: uniform = self._uniforms[key] except KeyError: raise Exception(f"A Uniform with the name `{key}` was not found.\n" f"The spelling may be incorrect, or if not in use it " f"may have been optimized out by the OpenGL driver.") try: uniform.set(value) except GLException: raise def __getitem__(self, item): try: uniform = self._uniforms[item] except KeyError: raise Exception(f"A Uniform with the name `{item}` was not found.\n" f"The spelling may be incorrect, or if not in use it " f"may have been optimized out by the OpenGL driver.") try: return uniform.get() except GLException: raise def _get_number(self, variable_type): """Get the number of active variables of the passed GL type.""" number = GLint(0) glGetProgramiv(self._id, variable_type, byref(number)) return number.value def _introspect_attributes(self): program = self._id attributes = {} for index in range(self._get_number(GL_ACTIVE_ATTRIBUTES)): a_name, a_type, a_size = self._query_attribute(index) loc = glGetAttribLocation(program, create_string_buffer(a_name.encode('utf-8'))) count, fmt = _attribute_types[a_type] attributes[a_name] = dict(type=a_type, size=a_size, location=loc, count=count, format=fmt) if _debug_gl_shaders: for attribute in attributes.values(): print(f" Found attribute: {attribute}") return attributes def _introspect_uniforms(self): program = self._id uniforms = {} for index in range(self._get_number(GL_ACTIVE_UNIFORMS)): u_name, u_type, u_size = self._query_uniform(index) loc = glGetUniformLocation(program, create_string_buffer(u_name.encode('utf-8'))) if loc == -1: # Skip uniforms that may be inside a Uniform Block continue uniforms[u_name] = _Uniform(program, u_name, u_type, loc, self._dsa) if _debug_gl_shaders: for uniform in uniforms.values(): print(f" Found uniform: {uniform}") return uniforms def _introspect_uniform_blocks(self): program = self._id uniform_blocks = {} for index in range(self._get_number(GL_ACTIVE_UNIFORM_BLOCKS)): name = self._get_uniform_block_name(index) num_active = GLint() block_data_size = GLint() glGetActiveUniformBlockiv(program, index, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, num_active) glGetActiveUniformBlockiv(program, index, GL_UNIFORM_BLOCK_DATA_SIZE, block_data_size) indices = (GLuint * num_active.value)() indices_ptr = cast(addressof(indices), POINTER(GLint)) glGetActiveUniformBlockiv(program, index, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices_ptr) uniforms = {} for block_uniform_index in indices: uniform_name, u_type, u_size = self._query_uniform(block_uniform_index) # Separate uniform name from block name (Only if instance name is provided on the Uniform Block) try: _, uniform_name = uniform_name.split(".") except ValueError: pass gl_type, _, _, length, _ = _uniform_setters[u_type] uniforms[block_uniform_index] = (uniform_name, gl_type, length) uniform_blocks[name] = UniformBlock(self, name, index, block_data_size.value, uniforms) # This might cause an error if index > GL_MAX_UNIFORM_BUFFER_BINDINGS, but surely no # one would be crazy enough to use more than 36 uniform blocks, right? glUniformBlockBinding(self.id, index, index) if _debug_gl_shaders: for block in uniform_blocks.values(): print(f" Found uniform block: {block}") return uniform_blocks def _get_uniform_block_name(self, index): buf_size = 128 size = c_int(0) name_buf = create_string_buffer(buf_size) try: glGetActiveUniformBlockName(self._id, index, buf_size, size, name_buf) return name_buf.value.decode() except GLException: return None def _query_attribute(self, index): asize = GLint() atype = GLenum() buf_size = 192 aname = create_string_buffer(buf_size) try: glGetActiveAttrib(self._id, index, buf_size, None, asize, atype, aname) return aname.value.decode(), atype.value, asize.value except GLException: raise def _query_uniform(self, index): usize = GLint() utype = GLenum() buf_size = 192 uname = create_string_buffer(buf_size) try: glGetActiveUniform(self._id, index, buf_size, None, usize, utype, uname) return uname.value.decode(), utype.value, usize.value except GLException: raise def vertex_list(self, count, mode, batch=None, group=None, **data): """Create a VertexList. :Parameters: `count` : int The number of vertices in the list. `mode` : int OpenGL drawing mode enumeration; for example, one of ``GL_POINTS``, ``GL_LINES``, ``GL_TRIANGLES``, etc. `batch` : `~pyglet.graphics.Batch` Batch to add the VertexList to, or ``None`` if a Batch will not be used. Using a Batch is strongly recommended. `group` : `~pyglet.graphics.Group` Group to add the VertexList to, or ``None`` if no group is required. `**data` : str or tuple Attribute formats and initial data for the vertex list. :rtype: :py:class:`~pyglet.graphics.vertexdomain.VertexList` """ attributes = self._attributes.copy() initial_arrays = [] for name, fmt in data.items(): try: if isinstance(fmt, tuple): fmt, array = fmt initial_arrays.append((name, array)) attributes[name] = {**attributes[name], **{'format': fmt}} except KeyError: raise ShaderException(f"\nThe attribute `{name}` doesn't exist. Valid names: \n{list(attributes)}") batch = batch or pyglet.graphics.get_default_batch() domain = batch.get_domain(False, mode, group, self._id, attributes) # Create vertex list and initialize vlist = domain.create(count) for name, array in initial_arrays: vlist.set_attribute_data(name, array) return vlist def vertex_list_indexed(self, count, mode, indices, batch=None, group=None, **data): """Create a IndexedVertexList. :Parameters: `count` : int The number of vertices in the list. `mode` : int OpenGL drawing mode enumeration; for example, one of ``GL_POINTS``, ``GL_LINES``, ``GL_TRIANGLES``, etc. `indices` : sequence of int Sequence of integers giving indices into the vertex list. `batch` : `~pyglet.graphics.Batch` Batch to add the VertexList to, or ``None`` if a Batch will not be used. Using a Batch is strongly recommended. `group` : `~pyglet.graphics.Group` Group to add the VertexList to, or ``None`` if no group is required. `**data` : str or tuple Attribute formats and initial data for the vertex list. :rtype: :py:class:`~pyglet.graphics.vertexdomain.IndexedVertexList` """ attributes = self._attributes.copy() initial_arrays = [] for name, fmt in data.items(): try: if isinstance(fmt, tuple): fmt, array = fmt initial_arrays.append((name, array)) attributes[name] = {**attributes[name], **{'format': fmt}} except KeyError: raise ShaderException(f"\nThe attribute `{name}` doesn't exist. Valid names: \n{list(attributes)}") batch = batch or pyglet.graphics.get_default_batch() domain = batch.get_domain(True, mode, group, self._id, attributes) # Create vertex list and initialize vlist = domain.create(count, len(indices)) start = vlist.start vlist.indices = [i + start for i in indices] for name, array in initial_arrays: vlist.set_attribute_data(name, array) return vlist def __repr__(self): return "{0}(id={1})".format(self.__class__.__name__, self.id) class UniformBlock: __slots__ = 'program', 'name', 'index', 'size', 'uniforms', 'view_cls' def __init__(self, program, name, index, size, uniforms): self.program = proxy(program) self.name = name self.index = index self.size = size self.uniforms = uniforms self.view_cls = None def create_ubo(self, index=0): """ Create a new UniformBufferObject from this uniform block. :Parameters: `index` : int The uniform buffer index the returned UBO will bind itself to. By default this is 0. :rtype: :py:class:`~pyglet.graphics.shader.UniformBufferObject` """ if self.view_cls is None: self.view_cls = self._introspect_uniforms() return UniformBufferObject(self.view_cls, self.size, index) def _introspect_uniforms(self): """Introspect the block's structure and return a ctypes struct for manipulating the uniform block's members. """ p_id = self.program.id index = self.index active_count = len(self.uniforms) # Query the uniform index order and each uniform's offset: indices = (GLuint * active_count)() offsets = (GLint * active_count)() indices_ptr = cast(addressof(indices), POINTER(GLint)) offsets_ptr = cast(addressof(offsets), POINTER(GLint)) glGetActiveUniformBlockiv(p_id, index, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices_ptr) glGetActiveUniformsiv(p_id, active_count, indices, GL_UNIFORM_OFFSET, offsets_ptr) # Offsets may be returned in non-ascending order, sort them with the corresponding index: _oi = sorted(zip(offsets, indices), key=lambda x: x[0]) offsets = [x[0] for x in _oi] + [self.size] indices = (GLuint * active_count)(*(x[1] for x in _oi)) # # Query other uniform information: # gl_types = (GLint * active_count)() # mat_stride = (GLint * active_count)() # gl_types_ptr = cast(addressof(gl_types), POINTER(GLint)) # stride_ptr = cast(addressof(mat_stride), POINTER(GLint)) # glGetActiveUniformsiv(p_id, active_count, indices, GL_UNIFORM_TYPE, gl_types_ptr) # glGetActiveUniformsiv(p_id, active_count, indices, GL_UNIFORM_MATRIX_STRIDE, stride_ptr) view_fields = [] for i in range(active_count): u_name, gl_type, length = self.uniforms[indices[i]] size = offsets[i+1] - offsets[i] c_type_size = sizeof(gl_type) actual_size = c_type_size * length padding = size - actual_size # TODO: handle stride for multiple matrixes in the same UBO (crashes now) # m_stride = mat_stride[i] arg = (u_name, gl_type * length) if length > 1 else (u_name, gl_type) view_fields.append(arg) if padding > 0: padding_bytes = padding // c_type_size view_fields.append((f'_padding{i}', gl_type * padding_bytes)) # Custom ctypes Structure for Uniform access: class View(Structure): _fields_ = view_fields __repr__ = lambda self: str(dict(self._fields_)) return View def __repr__(self): return f"{self.__class__.__name__}(name={self.name}, index={self.index})" class UniformBufferObject: __slots__ = 'buffer', 'view', '_view_ptr', 'index' def __init__(self, view_class, buffer_size, index): self.buffer = BufferObject(buffer_size) self.view = view_class() self._view_ptr = pointer(self.view) self.index = index @property def id(self): return self.buffer.id def bind(self, index=None): glBindBufferBase(GL_UNIFORM_BUFFER, self.index if index is None else index, self.buffer.id) def read(self): """Read the byte contents of the buffer""" glBindBuffer(GL_ARRAY_BUFFER, self.buffer.id) ptr = glMapBufferRange(GL_ARRAY_BUFFER, 0, self.buffer.size, GL_MAP_READ_BIT) data = string_at(ptr, size=self.buffer.size) glUnmapBuffer(GL_ARRAY_BUFFER) return data def __enter__(self): # Return the view to the user in a `with` context: return self.view def __exit__(self, exc_type, exc_val, exc_tb): self.bind() self.buffer.set_data(self._view_ptr) def __repr__(self): return "{0}(id={1})".format(self.__class__.__name__, self.buffer.id)