def draw_lights(lights, shader, models):
"""
Dependencies are location, rotation, scale, and model (optionally texture).
Args:
lights:
shader:
models:
Returns:
"""
attribute_location = shader.attribute_location
location_location = attribute_location['location']
for entity in lights:
shader.load_uniform_matrix(entity.transformation, name='transform')
model = models[entity.model]
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
glEnableVertexAttribArray(location_location)
glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
glDrawElements(GL_TRIANGLES, model.indexed_vbo.count, GL_UNSIGNED_INT,
0)
glDisableVertexAttribArray(location_location)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def draw(self, uniforms, text, quad, textures=(), *args, **kwargs):
glUseProgram(self)
glDisable(GL_DEPTH_TEST)
quad.enable()
glUniform3f(self.uniforms[b'color'], 0.3, 0.3, 0.5)
glUniformMatrix3fv(
self.uniforms[b'transformation'], 1, GL_TRUE,
text.get_transformation_matrix_2D().ctypes.data_as(POINTER(GLfloat))
)
textures.enable(slot=0)
glUniform1i(self.uniforms[b'font_atlas'], 0)
quad.draw()
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindTexture(GL_TEXTURE_2D, 0)
glDisableVertexAttribArray(0)
glEnable(GL_DEPTH_TEST)
def draw(self, uniforms, entities, models, *args, **kwargs):
glUseProgram(self)
glUniformMatrix4fv(
self.uniforms[b'perspective'], 1, GL_TRUE, uniforms.get(b'perspective').ctypes.data_as(POINTER(GLfloat))
)
glUniformMatrix4fv(
self.uniforms[b'view'], 1, GL_TRUE, uniforms.get(b'view').ctypes.data_as(POINTER(GLfloat))
)
for model_index, entity_list in entities.items():
model = models[model_index]
model.enable()
for entity in entity_list:
glUniformMatrix4fv(
self.uniforms[b'transformation'], 1, GL_TRUE,
entity.get_transformation_matrix().ctypes.data_as(POINTER(GLfloat))
)
glUniform3f(self.uniforms[b'color'], *entity.color)
model.draw()
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindTexture(GL_TEXTURE_2D, 0)
glDisableVertexAttribArray(0)
def draw(self, shader):
attribute_table = shader.attribute_table
self.indexed_vbo.bind()
# Bind all attributes.
location_list = [] # Used to disable all VertexAttribArrays.
for name, vbo in self.vbo_array.items():
vbo.bind()
attribute_location = attribute_table[name]
location_list.append(attribute_location)
glEnableVertexAttribArray(attribute_location)
# specify that the data for the attribute will be pulled from the buffer that is currently bound to
# GL_ARRAY_BUFFER. (http://stackoverflow.com/questions/30016833/multiple-in-attributes-in-shader-opengl)
glVertexAttribPointer(attribute_location, vbo.dimension,
vbo.data_type, GL_FALSE, 0, 0)
# Draw.
# glDrawArrays(GL_TRIANGLES, 0, vbo.count)
glDrawElements(GL_TRIANGLES, self.indexed_vbo.count,
self.indexed_vbo.data_type, 0)
# Disable and unbind everything.
for location in location_list:
glDisableVertexAttribArray(location)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def draw(self):
"""Draw the object to the display buffer"""
from pyglet import gl
gl.glUseProgram(self._program)
for kind in ('fill', 'line'):
if self._counts[kind] > 0:
if kind == 'line':
if self._line_width <= 0.0:
continue
gl.glLineWidth(self._line_width)
if self._line_loop:
mode = gl.GL_LINE_LOOP
else:
mode = gl.GL_LINE_STRIP
cmd = partial(gl.glDrawArrays, mode, 0, self._counts[kind])
else:
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER,
self._buffers[kind]['index'])
cmd = partial(gl.glDrawElements, gl.GL_TRIANGLES,
self._counts[kind], gl.GL_UNSIGNED_INT, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,
self._buffers[kind]['array'])
loc_pos = gl.glGetAttribLocation(self._program, b'a_position')
gl.glEnableVertexAttribArray(loc_pos)
gl.glVertexAttribPointer(loc_pos, 2, gl.GL_FLOAT, gl.GL_FALSE,
0, 0)
loc_col = gl.glGetUniformLocation(self._program, b'u_color')
gl.glUniform4f(loc_col, *self._colors[kind])
cmd()
# The following line is probably only necessary because
# Pyglet makes some assumptions about the GL state that
# it perhaps shouldn't. Without it, Text might not
# render properly (see #252)
gl.glDisableVertexAttribArray(loc_pos)
gl.glUseProgram(0)
def draw(self):
"""Draw the object to the display buffer"""
from pyglet import gl
gl.glUseProgram(self._program)
for kind in ('fill', 'line'):
if self._counts[kind] > 0:
if kind == 'line':
if self._line_width <= 0.0:
continue
gl.glLineWidth(self._line_width)
if self._line_loop:
mode = gl.GL_LINE_LOOP
else:
mode = gl.GL_LINE_STRIP
cmd = partial(gl.glDrawArrays, mode, 0, self._counts[kind])
else:
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER,
self._buffers[kind]['index'])
cmd = partial(gl.glDrawElements, gl.GL_TRIANGLES,
self._counts[kind], gl.GL_UNSIGNED_INT, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,
self._buffers[kind]['array'])
loc_pos = gl.glGetAttribLocation(self._program, b'a_position')
gl.glEnableVertexAttribArray(loc_pos)
gl.glVertexAttribPointer(loc_pos, 2, gl.GL_FLOAT, gl.GL_FALSE,
0, 0)
loc_col = gl.glGetUniformLocation(self._program, b'u_color')
gl.glUniform4f(loc_col, *self._colors[kind])
cmd()
# The following line is probably only necessary because
# Pyglet makes some assumptions about the GL state that
# it perhaps shouldn't. Without it, Text might not
# render properly (see #252)
gl.glDisableVertexAttribArray(loc_pos)
gl.glUseProgram(0)
def draw(self):
"""Draw the text to the back buffer"""
# Border width
self.box.setLineWidth(
self.palette['lineWidth']) # Use 1 as base if border width is none
#self.borderWidth = self.box.lineWidth
# Border colour
self.box.setLineColor(self.palette['lineColor'], colorSpace='rgb')
#self.borderColor = self.box.lineColor
# Background
self.box.setFillColor(self.palette['fillColor'], colorSpace='rgb')
#self.fillColor = self.box.fillColor
if self._needVertexUpdate:
#print("Updating vertices...")
self._updateVertices()
if self.fillColor is not None or self.borderColor is not None:
self.box.draw()
# self.boundingBox.draw() # could draw for debug purposes
gl.glPushMatrix()
self.win.setScale('pix')
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.glFont.textureID)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_DOUBLE, 0, self.verticesPix.ctypes)
gl.glColorPointer(4, gl.GL_DOUBLE, 0, self._colors.ctypes)
gl.glTexCoordPointer(2, gl.GL_DOUBLE, 0, self._texcoords.ctypes)
self.shader.bind()
self.shader.setInt('texture', 0)
self.shader.setFloat('pixel', [1.0 / 512, 1.0 / 512])
nVerts = len(self._text) * 4
gl.glDrawArrays(gl.GL_QUADS, 0, nVerts)
self.shader.unbind()
# removed the colors and font texture
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glDisableVertexAttribArray(1)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, 0)
gl.glDisable(gl.GL_TEXTURE_2D)
if self.hasFocus: # draw caret line
self.caret.draw()
gl.glPopMatrix()
def draw(self,
uniforms,
entity,
models,
textures=(),
color=(1.0, 1.0, 1.0),
*args,
**kwargs):
glUseProgram(self)
glDisable(GL_DEPTH_TEST)
# Draw objects once as invisible to set stencil values.
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE,
GL_FALSE) # Don't write any color values to color buffer.
glStencilMask(0xFF) # Enable writing.
model = models[entity.model]
model.positions.enable()
model.indices.enable()
self.uniforms[b'perspective'].load(
uniforms.get(b'perspective').ctypes.data_as(POINTER(GLfloat)))
self.uniforms[b'view'].load(
uniforms.get(b'view').ctypes.data_as(POINTER(GLfloat)))
self.uniforms[b'color'].load(*color)
entity.get_transformation_matrix(
location=self.uniforms[b'transformation'])
model.draw()
# Draw again with larger model.
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)
glStencilFunc(GL_NOTEQUAL, 1,
0xFF) # Update with 1's where the objects are rendered.
glStencilMask(
0x00
) # Value that AND's the value written to buffer. 0x00 basically disables writing to stencil.
glUniformMatrix4fv(
self.uniforms[b'transformation'], 1, GL_TRUE,
create_transformation_matrix(
*entity._location, *entity.rotation,
*(entity.scale + 0.05)).ctypes.data_as(POINTER(GLfloat)))
model.draw()
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glDisableVertexAttribArray(0)
glEnable(GL_DEPTH_TEST)
glStencilMask(0xFF)
def draw(self, uniforms, text, quad, textures=(), *args, **kwargs):
glUseProgram(self)
glDisable(GL_DEPTH_TEST)
quad.enable()
self.uniforms[b'color'].load(0.3, 0.3, 0.5)
text.get_transformation_matrix_2D(
location=self.uniforms[b'transformation'])
textures.enable()
quad.draw()
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glDisableVertexAttribArray(0)
glEnable(GL_DEPTH_TEST)
def draw(self, uniforms, entities, models, textures=(), lights=(), *args, **kwargs):
glUseProgram(self)
# PREPARE SHADER
glUniformMatrix4fv( # ctypes.data_as must be here and not at initialization.
self.uniforms[b'perspective'], 1, GL_TRUE, uniforms.get(b'perspective').ctypes.data_as(POINTER(GLfloat))
)
glUniformMatrix4fv(
self.uniforms[b'view'], 1, GL_TRUE, uniforms.get(b'view').ctypes.data_as(POINTER(GLfloat))
)
for i, entity in enumerate(lights):
glUniform3f(self.uniforms[b'light[' + bytes(str(i), 'utf-8') + b'].position'], *entity.location)
glUniform3f(self.uniforms[b'light[' + bytes(str(i), 'utf-8') + b'].color'], *entity.color)
glUniform1f(self.uniforms[b'light[' + bytes(str(i), 'utf-8') + b'].constant'], entity.attenuation[0])
glUniform1f(self.uniforms[b'light[' + bytes(str(i), 'utf-8') + b'].linear'], entity.attenuation[1])
glUniform1f(self.uniforms[b'light[' + bytes(str(i), 'utf-8') + b'].quadratic'], entity.attenuation[1])
# PREPARE MODELS
for model_index, texture_mapping in self.entities.items():
model = models[model_index]
model.enable()
# PREPARE TEXTURES
glActiveTexture(GL_TEXTURE0)
glActiveTexture(GL_TEXTURE0 + 1)
for texture_list, entity_list in texture_mapping.items():
if hasattr(texture_list, '__iter__'):
glBindTexture(GL_TEXTURE_2D, textures[0])
glUniform1i(self.uniforms[b'diffuse_texture'], 0)
glBindTexture(GL_TEXTURE_2D, textures[1])
glUniform1i(self.uniforms[b'specular_texture'], 1)
# textures[0].enable(slot=0)
# textures[1].enable(slot=1)
else:
textures[texture_list].enable(slot=0)
glUniform1i(self.uniforms[b'diffuse_texture'], 0)
# PREPARE ENTITIES
for entity in entity_list:
glUniformMatrix4fv(
self.uniforms[b'transformation'], 1, GL_TRUE,
entity.get_transformation_matrix().ctypes.data_as(POINTER(GLfloat))
)
model.draw()
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindTexture(GL_TEXTURE_2D, 0)
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
glDisableVertexAttribArray(2)
def draw_entities(entities, shader, models):
"""
Dependencies are location, rotation, scale, and model (optionally texture).
Args:
shader:
models:
Returns:
"""
attribute_location = shader.attribute_location
location_location = attribute_location['location']
texture_location = attribute_location['texture_coordinate']
normal_location = attribute_location['normal']
for entity in entities:
model = models[entity.model]
shader.set_uniform_matrix('transform', entity.transformation)
# glActiveTexture(GL_TEXTURE0)
# texture = textures[entity.diffuse]
# glBindTexture(GL_TEXTURE_2D, texture.id)
# glActiveTexture(GL_TEXTURE0 + 1)
# texture = textures[entity.specular]
# glBindTexture(GL_TEXTURE_2D, texture.id)
# glActiveTexture(GL_TEXTURE0 + 2)
# texture = textures[entity.emission]
# glBindTexture(GL_TEXTURE_2D, texture.id)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
glEnableVertexAttribArray(location_location)
glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['texture_coordinate'])
glEnableVertexAttribArray(texture_location)
glVertexAttribPointer(texture_location, 2, GL_FLOAT, GL_FALSE, 0, 0)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['normal'])
glEnableVertexAttribArray(normal_location)
glVertexAttribPointer(normal_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
glDrawElements(GL_TRIANGLES, model.indexed_vbo.count, GL_UNSIGNED_INT,
0)
Entity.needs_update.clear()
glDisableVertexAttribArray(location_location)
glDisableVertexAttribArray(texture_location)
glDisableVertexAttribArray(normal_location)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def draw(self):
gl.glPushMatrix()
self.transform()
# color preserve - at least nvidia 6150SE needs that
gl.glPushAttrib(gl.GL_CURRENT_BIT)
# glPointSize(self.get_scaled_particle_size())
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glEnable(gl.GL_PROGRAM_POINT_SIZE)
# glBindTexture(GL_TEXTURE_2D, self.texture.id)
gl.glEnable(gl.GL_POINT_SPRITE)
gl.glTexEnvi(gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
vertex_ptr = PointerToNumpy(self.particle_pos)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertex_ptr)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
color_ptr = PointerToNumpy(self.particle_color)
gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr)
gl.glEnableVertexAttribArray(self.particle_size_idx)
size_ptr = PointerToNumpy(self.particle_size_scaled)
gl.glVertexAttribPointer(self.particle_size_idx, 1, gl.GL_FLOAT,
False, 0, size_ptr)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
if self.blend_additive:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
else:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# mode = GLint()
# glTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode )
#
# if self.color_modulate:
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE )
# else:
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE )
self.sprite_shader.install()
self.sprite_shader.usetTex('sprite_texture', 0,
gl.GL_TEXTURE_2D, self.texture.id)
gl.glDrawArrays(gl.GL_POINTS, 0, self.total_particles)
self.sprite_shader.uninstall()
# un -blend
gl.glPopAttrib()
# color restore
gl.glPopAttrib()
# restore env mode
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode)
# disable states
gl.glDisableVertexAttribArray(self.particle_size_idx)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisable(gl.GL_POINT_SPRITE)
gl.glDisable(gl.GL_PROGRAM_POINT_SIZE)
gl.glDisable(gl.GL_TEXTURE_2D)
gl.glPopMatrix()
def disable(self):
" Disable the shader attribute "
glDisableVertexAttribArray(self.loc)
def disable(self):
for index in range(len(self.vbos)):
glDisableVertexAttribArray(index)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def disable(self):
for index in range(len(self.vbos)):
glDisableVertexAttribArray(index)
self.ibo.disable()
def draw(self, shader, models, textures):
"""
Dependencies are location, rotation, scale, and model (optionally texture).
Args:
shader:
models:
textures:
Returns:
"""
attribute_location = shader.attribute_location
location_location = attribute_location['position']
texture_location = attribute_location['texture_coordinate']
normal_location = attribute_location['normal']
transformation = self.transformation
diffuse = self.diffuse
specular = self.specular
emission = self.emission
for entity in numpy.where(
(self.mask & World.COMPONENT_SPRITE) == World.COMPONENT_SPRITE)[0]:
model = models[self.model[entity]]
shader.load_uniform_matrix(transformation[entity],
name='transform')
glActiveTexture(GL_TEXTURE0)
texture = textures[diffuse[entity]]
glBindTexture(GL_TEXTURE_2D, texture.id)
glActiveTexture(GL_TEXTURE0 + 1)
texture = textures[specular[entity]]
glBindTexture(GL_TEXTURE_2D, texture.id)
glActiveTexture(GL_TEXTURE0 + 2)
texture = textures[emission[entity]]
glBindTexture(GL_TEXTURE_2D, texture.id)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
glEnableVertexAttribArray(location_location)
glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0,
0)
glBindBuffer(GL_ARRAY_BUFFER,
model.vbo_array['texture_coordinate'])
glEnableVertexAttribArray(texture_location)
glVertexAttribPointer(texture_location, 2, GL_FLOAT, GL_FALSE, 0,
0)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['normal'])
glEnableVertexAttribArray(normal_location)
glVertexAttribPointer(normal_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
glDrawElements(GL_TRIANGLES, model.indexed_vbo.count,
GL_UNSIGNED_INT, 0)
glDisableVertexAttribArray(location_location)
glDisableVertexAttribArray(texture_location)
glDisableVertexAttribArray(normal_location)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def draw_light(self, shader, models):
"""
Dependencies are location, rotation, scale, and model (optionally texture).
Args:
shader:
models:
Returns:
"""
attribute_location = shader.attribute_location
location_location = attribute_location['position']
for entity in numpy.where(self.mask == World.COMPONENT_LIGHT)[0]:
shader.load_uniform_matrix(create_transformation_matrix(
*self.location[entity], *self.rotation[entity],
*self.scale[entity]),
name='transform')
model = models[self.model[entity]]
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
glEnableVertexAttribArray(location_location)
glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0,
0)
glDrawElements(GL_TRIANGLES, model.indexed_vbo.count,
GL_UNSIGNED_INT, 0)
glDisableVertexAttribArray(location_location)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
#
#
#
#
# class World:
# # Must be of same data type as 'mask' array.
# COMPONENT_VOID = numpy.uint(0)
# COMPONENT_DISPLACEMENT = numpy.uint(1 << 0)
# COMPONENT_MODEL = numpy.uint(1 << 1)
# COMPONENT_TEXTURE = numpy.uint(1 << 2)
#
# COMPONENT_LIGHT = COMPONENT_DISPLACEMENT | COMPONENT_MODEL
# COMPONENT_SPRITE = COMPONENT_DISPLACEMENT | COMPONENT_MODEL | COMPONENT_TEXTURE
#
# def __init__(self, max_entities):
# self.max_entities = max_entities
# self.entity_count = 0
#
# self.mask = numpy.zeros(shape=max_entities, dtype=numpy.uint, order='C')
#
# # Displacement.
# self.location = numpy.zeros(shape=(max_entities, 3), dtype=numpy.float32, order='C')
# self.rotation = numpy.zeros(shape=(max_entities, 3), dtype=numpy.float32, order='C')
# self.scale = numpy.zeros(shape=(max_entities, 3), dtype=numpy.float32, order='C')
# self.transformation = numpy.zeros(shape=(max_entities, 4, 4), dtype=numpy.float32, order='C')
#
# # Model.
# self.model = numpy.zeros(shape=max_entities, dtype=numpy.uint, order='C')
#
# # Texture.
# self.diffuse = numpy.zeros(shape=max_entities, dtype=numpy.uint, order='C')
# self.specular = numpy.zeros(shape=max_entities, dtype=numpy.uint, order='C')
# self.emission = numpy.zeros(shape=max_entities, dtype=numpy.uint, order='C')
#
#
# def create_entity(world, **attributes) -> int:
# """
# Generates a handle for an entity.
#
# Returns:
# int
# """
# handle = world.entity_count
# world.entity_count += 1
#
# if world.entity_count > world.max_entities:
# raise ValueError('Maximum entity count of %i reached!' % world.max_entities)
#
# for key, value in attributes.items():
# attribute_array = getattr(world, key)
# attribute_array[handle][:] = value
#
# return handle
#
#
# def remove_entity(world, entity):
# world.mask[entity] = World.COMPONENT_VOID
#
#
# def draw(world, mask, shader, models, textures):
# """
#
#
# Dependencies are location, rotation, scale, and model (optionally texture).
#
# Args:
# world:
# mask:
# shader:
# models:
# textures:
#
# Returns:
#
# """
# attribute_location = shader.attribute_location
# location_location = attribute_location['location']
# texture_location = attribute_location['texture_coordinate']
# normal_location = attribute_location['normal']
#
# for entity in numpy.where((world.mask & mask) == mask)[0]:
# model = models[world.model[entity]]
#
# shader.load_uniform_matrix(world.transformation[entity], name='transform')
#
# glActiveTexture(GL_TEXTURE0)
# texture = textures[world.diffuse[entity]]
# glBindTexture(GL_TEXTURE_2D, texture.id)
# glActiveTexture(GL_TEXTURE0 + 1)
# texture = textures[world.specular[entity]]
# glBindTexture(GL_TEXTURE_2D, texture.id)
# glActiveTexture(GL_TEXTURE0 + 2)
# texture = textures[world.emission[entity]]
# glBindTexture(GL_TEXTURE_2D, texture.id)
#
# glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
#
# glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
# glEnableVertexAttribArray(location_location)
# glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
#
# glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['texture_coordinate'])
# glEnableVertexAttribArray(texture_location)
# glVertexAttribPointer(texture_location, 2, GL_FLOAT, GL_FALSE, 0, 0)
#
# glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['normal'])
# glEnableVertexAttribArray(normal_location)
# glVertexAttribPointer(normal_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
#
# glDrawElements(GL_TRIANGLES, model.indexed_vbo.count, GL_UNSIGNED_INT, 0)
#
# glDisableVertexAttribArray(location_location)
# glDisableVertexAttribArray(texture_location)
# glDisableVertexAttribArray(normal_location)
# glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
# glBindBuffer(GL_ARRAY_BUFFER, 0)
#
#
# def draw_light(world, shader, models):
# """
#
#
# Dependencies are location, rotation, scale, and model (optionally texture).
#
# Args:
# world:
# shader:
# models:
#
# Returns:
#
# """
# attribute_location = shader.attribute_location
# location_location = attribute_location['location']
#
# for entity in numpy.where(world.mask == World.COMPONENT_LIGHT)[0]:
# shader.load_uniform_matrix(world.transformation[entity], name='transform')
#
# model = models[world.model[entity]]
#
# glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, model.indexed_vbo)
#
# glBindBuffer(GL_ARRAY_BUFFER, model.vbo_array['location'])
# glEnableVertexAttribArray(location_location)
# glVertexAttribPointer(location_location, 3, GL_FLOAT, GL_FALSE, 0, 0)
#
# glDrawElements(GL_TRIANGLES, model.indexed_vbo.count, GL_UNSIGNED_INT, 0)
#
# glDisableVertexAttribArray(location_location)
# glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
# glBindBuffer(GL_ARRAY_BUFFER, 0)
def draw(self):
"""Draw the particles system"""
gl.glPushMatrix()
self.transform()
# color preserve - at least nvidia 6150SE needs that
gl.glPushAttrib(gl.GL_CURRENT_BIT)
# glPointSize(self.get_scaled_particle_size())
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glEnable(gl.GL_PROGRAM_POINT_SIZE)
# glBindTexture(GL_TEXTURE_2D, self.texture.id)
gl.glEnable(gl.GL_POINT_SPRITE)
gl.glTexEnvi(gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
vertex_ptr = PointerToNumpy(self.particle_pos)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertex_ptr)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
color_ptr = PointerToNumpy(self.particle_color)
gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr)
gl.glEnableVertexAttribArray(self.particle_size_idx)
size_ptr = PointerToNumpy(self.particle_size_scaled)
gl.glVertexAttribPointer(self.particle_size_idx, 1, gl.GL_FLOAT,
False, 0, size_ptr)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
if self.blend_additive:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
else:
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# mode = GLint()
# glTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode )
#
# if self.color_modulate:
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE )
# else:
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE )
self.sprite_shader.install()
self.sprite_shader.usetTex('sprite_texture', 0,
gl.GL_TEXTURE_2D, self.texture.id)
gl.glDrawArrays(gl.GL_POINTS, 0, self.total_particles)
self.sprite_shader.uninstall()
# un -blend
gl.glPopAttrib()
# color restore
gl.glPopAttrib()
# restore env mode
# glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode)
# disable states
gl.glDisableVertexAttribArray(self.particle_size_idx)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisable(gl.GL_POINT_SPRITE)
gl.glDisable(gl.GL_PROGRAM_POINT_SIZE)
gl.glDisable(gl.GL_TEXTURE_2D)
gl.glPopMatrix()
