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 __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 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, 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 __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):
self.handle = GLuint()
glGenVertexArrays(1, self.handle)
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 = {}
