def __init__(self, position): self.vertices = [] self.voxels = {} self.chunk_position = position self.world_position = tuple([x * CHUNK_SIZE for x in position]) self.vbo = GLuint() self.vao = GLuint() self.gen_voxels() self.gen_vertices()
def __init__(self, buffer_id, format, usage=GL_DYNAMIC_DRAW, owned=False): self.bid = GLuint(getattr(buffer_id, 'value', buffer_id)) self.owned = owned self._usage = usage self.format = BufferFormat.new(format) self.target = None self.mapinfo = None
def upload(self): ''' Upload atlas data into video memory. ''' glEnable(GL_TEXTURE_2D) if self.texid is None: self.texid = GLuint(0) glGenTextures(1, ctypes.byref(self.texid)) glBindTexture(GL_TEXTURE_2D, self.texid) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) if self.depth == 1: glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, self.width, self.height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, self.data.ctypes) elif self.depth == 3: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, self.width, self.height, 0, GL_RGB, GL_UNSIGNED_BYTE, self.data.ctypes) else: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, self.data.ctypes) glBindTexture(GL_TEXTURE_2D, 0)
def get_uniform_data(program): """ Args: program: Returns: """ uniforms = {} count = pointer(GLint()) buffer_size = GLsizei(32) length = GLsizei() size = GLint() data_type = GLenum() uniform_name = c_string('', size=buffer_size.value) glGetProgramiv(program, GL_ACTIVE_UNIFORMS, count) for i in range(count.contents.value): glGetActiveUniform(program, GLuint(i), buffer_size, length, size, data_type, uniform_name) uniform_name_ = uniform_name.value.decode('utf-8') data_type_string = temp[data_type.value] uniforms[uniform_name_] = { 'dtype': table[data_type_string]['dtype'], 'index': i, 'size': size.value, 'value': None, 'location': glGetUniformLocation(program, uniform_name), 'function': table[data_type_string]['function'], } print(uniform_name_, uniforms[uniform_name_]) return uniforms
def __init__(self, buffer_type, nums_per_vertex, data, data_type): self.type = buffer_type self.nums_per_vertex = nums_per_vertex self.uploaded = False self.data = data self.data_type = data_type self.handle = GLuint() glGenBuffers(1, self.handle)
def cache_item_build(self, loc, size, name, type): """ Add an item to the cache. This is called by reload. """ attribinfo = ShaderAttribute() attribinfo.loc = GLuint(loc.value) attribinfo.type = type attribinfo.name = name self.cache[name] = attribinfo
def create(cls, data, dimension, type=GLfloat, draw_mode=GL_STATIC_DRAW): assert type in VBO.VALID_TYPES, "Invalid type for VBO!" handle = GLuint() glGenBuffers(1, handle) glBindBuffer(VBO.TARGET, handle) glBufferData(VBO.TARGET, len(data) * sizeof(type), (type * len(data))(*data), draw_mode) return cls(handle, dimension, GL_TYPE_TO_CONSTANT[type])
def __init__(self, image, f, t): self.image = image self.format = f self.type = t self.uploaded = False self.handle = GLuint() glGenTextures(1, self.handle) glBindTexture(GL_TEXTURE_2D, self.handle) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
def __init__(self, data, usage=GL_STATIC_DRAW): """ Initiate the vertex buffer object on the CPU """ self.buffer = GLuint(0) glGenBuffers(1, self.buffer) self.buffer = self.buffer.value glBindBuffer(GL_ARRAY_BUFFER, self.buffer) glBufferData(GL_ARRAY_BUFFER, ADT.arrayByteCount(data), ADT.voidDataPointer(data), usage)
def __alloc(cls, target, format, usage): buf = super().__new__(cls) buf.owned = True buf.bid = GLuint() glGenBuffers(1, byref(buf.bid)) glBindBuffer(target, buf.bid) buf._usage = usage buf.format = BufferFormat.new(format) buf.target = target buf.mapinfo = None return buf
def upload(asset: ModelAsset, gl_usage=GL_STATIC_DRAW): asset.vertex_array_id = GLuint() glGenVertexArrays(1, asset.vertex_array_id) asset.vertex_buffer_id = GLuint() glGenBuffers(1, asset.vertex_buffer_id) upload_vertices(asset, gl_usage) upload_indices(asset, gl_usage) if asset.texture is not None: glBindTexture(GL_TEXTURE_2D, asset.texture.id) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) # noinspection PyCallingNonCallable,PyTypeChecker texture_data = (GLubyte * len(asset.texture.buffer.flat))( *asset.texture.buffer.flatten()) glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, asset.texture.width, asset.texture.height, 0, asset.texture.format, asset.texture.type, texture_data)
def release(ctx: "Context", glo: gl.GLuint): """ Release/delete open gl buffer. This is automatically called when the object is garbage collected. """ # If we have no context, then we are shutting down, so skip this if gl.current_context is None: return if glo.value != 0: gl.glDeleteBuffers(1, byref(glo)) glo.value = 0 ctx.stats.decr("buffer")
def release(ctx: "Context", glo: gl.GLuint): """ Delete this object. This is automatically called when this object is garbage collected. """ # If we have no context, then we are shutting down, so skip this if gl.current_context is None: return if glo.value != 0: gl.glDeleteVertexArrays(1, byref(glo)) glo.value = 0 ctx.stats.decr("vertex_array")
def __init__(self): self.handle = GLuint() glGenVertexArrays(1, self.handle)
def __init__(self): """Create an instance of a Vertex Array object.""" self._id = GLuint() glGenVertexArrays(1, self._id)
def create_raw_buffer(): buf = GLuint() glGenBuffers(1, byref(buf)) glBindBuffer(GL_ARRAY_BUFFER, buf) return buf.value
def __del__(self): glDeleteBuffers(1, GLuint(self.buffer))
def __init__(self): """Create an instance of a Vertex Array object.""" self._context = pyglet.gl.current_context self._id = GLuint() glGenVertexArrays(1, self._id)
def __init__(self, shaders, attributes, uniforms): # Create vertex shader. vertex_shader = shaders[0] vertex_handle = glCreateShader(GL_VERTEX_SHADER) glShaderSource(vertex_handle, 1, c_string_array(vertex_shader), None) glCompileShader(vertex_handle) # Create fragment shader. fragment_shader = shaders[1] fragment_handle = glCreateShader(GL_FRAGMENT_SHADER) glShaderSource(fragment_handle, 1, c_string_array(fragment_shader), None) glCompileShader(fragment_handle) try: # Create program. program_handle = glCreateProgram() # Attach shaders glAttachShader(program_handle, vertex_handle) glAttachShader(program_handle, fragment_handle) # Bind attributes. for index, name in enumerate(attributes): glBindAttribLocation(program_handle, index, c_string(name)) # Link, validate and use. glLinkProgram(program_handle) glValidateProgram(program_handle) glUseProgram(program_handle) except GLException: # Print errors. status = GLint() glGetShaderiv(vertex_handle, GL_INFO_LOG_LENGTH, byref(status)) output = create_string_buffer(status.value) glGetShaderInfoLog(vertex_handle, status, None, output) print(output.value.decode('utf-8')) status = GLint() glGetShaderiv(fragment_handle, GL_INFO_LOG_LENGTH, byref(status)) output = create_string_buffer(status.value) glGetShaderInfoLog(fragment_handle, status, None, output) print(output.value.decode('utf-8')) status = GLint() glGetProgramiv(program_handle, GL_INFO_LOG_LENGTH, byref( status)) # Getting the number of char in info log to 'status' output = create_string_buffer(status.value) # status.value) glGetProgramInfoLog(program_handle, status, None, output) print(output.value.decode('utf-8')) # Query uniform data. active_uniforms = GLint() glGetProgramiv(program_handle, GL_ACTIVE_UNIFORMS, active_uniforms) buffer_size = GLsizei(255) data_type = GLenum(0) string_buffer = create_string_buffer(buffer_size.value) name = c_char_p(addressof(string_buffer)) uniform_mapping = {} for index in range(active_uniforms.value): glGetActiveUniform(program_handle, index, buffer_size, None, None, byref(data_type), name) if name.value in uniforms: location = glGetUniformLocation( program_handle, cast(pointer(name), POINTER(GLchar))) uniform = Uniform(name.value, location, data_type.value) uniform_mapping[name.value] = uniform self.id = GLuint(program_handle) self.uniforms = uniform_mapping self.attributes = attributes
def __init__(self): self.indices = [] self.id = GLuint() glGenBuffers(1, self.id)
def __init__(self): self.id = GLuint() glGenTextures(1, self.id) self.attributes = {}