def on_draw(self):
"""
Render the screen.
"""
start = time.time()
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glDisable(GL.GL_BLEND)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.vertex_vbo_id)
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.color_vbo_id)
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
GL.glColorPointer(3, GL.GL_FLOAT, 0, 0)
offset = 0
for shape in self.shape_list:
render_rect_filled(shape, offset)
offset += 4
elapsed = time.time() - start
print(elapsed)
def render(shape: VertexBuffer):
"""
Render an shape previously created with a ``create`` function.
"""
# Set color
if shape.color is None:
raise ValueError("Error: Color parameter not set.")
gl.glLoadIdentity()
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_vertex_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
if shape.line_width:
gl.glLineWidth(shape.line_width)
if len(shape.color) == 4:
gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2],
shape.color[3])
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
elif len(shape.color) == 3:
gl.glDisable(gl.GL_BLEND)
gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def __init__(self):
pts = generate_cyl_points().T
colors = np.zeros_like(pts)
colors[:,1]=1.0 # all green
n_pts = len(pts)
pts = map(float,pts.flat) # convert to flat list of floats
colors = map(float, colors.flat)
# Create ctypes arrays of the lists
vertices = (gl.GLfloat * (n_pts*3))(*pts)
colors = (gl.GLfloat * (n_pts*3))(*colors)
# Create a list of triangle indices.
indices = range(n_pts)
indices = (gl.GLuint * n_pts)(*indices)
# Compile a display list
self.list = gl.glGenLists(1)
gl.glNewList(self.list, gl.GL_COMPILE)
gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glColorPointer(3, gl.GL_FLOAT, 0, colors)
gl.glDrawElements(gl.GL_POINTS, len(indices), gl.GL_UNSIGNED_INT, indices)
gl.glPopClientAttrib()
gl.glEndList()
def update_display(verts,tex_coords,texture=bird_texture):
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_ALPHA_TEST)
gl.glAlphaFunc (gl.GL_GREATER, .1)
#gl.glEnable(gl.GL_BLEND)
#gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
n=len(verts[:])
#TODO verts._buffer.ctypes.data is awkward
gl.glVertexPointer(3, vert_dtype.gl, 0, verts[:].ctypes.data)
gl.glTexCoordPointer(3, tex_dtype.gl, 0, tex_coords[:].ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, n)
#unset state
gl.glPopAttrib()
gl.glDisable(texture.target)
def draw(self, transformation, **kwargs):
transformation.scale(self.width, self.height, 1)
color = self.color + (self.opacity,)
gl.glColor4fv((gl.GLfloat * 4)(*color))
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, self.vertices)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4)
def on_draw(self):
"""
Render the screen.
"""
start = time.time()
float_size = ctypes.sizeof(ctypes.c_float)
record_len = 10 * float_size
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glColor4ub(255, 0, 0, 255)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.rect_vbo.vbo_id)
GL.glVertexPointer(2, GL.GL_FLOAT, record_len, 0)
for i in range(len(self.shape_list)):
shape = self.shape_list[i]
GL.glLoadIdentity()
GL.glTranslatef(shape.x, shape.y, 0)
GL.glDrawArrays(GL.GL_QUADS, i * 8, 8)
# GL.glDrawArrays(GL.GL_QUADS,
# 0,
# self.rect_vbo.size)
elapsed = time.time() - start
print(elapsed)
def drawnvc( self, normals, points, colors, idxs ):
'''draw tri mesh using glDrawElements
using input normals points colors and indexes'''
n = 1
for dim in idxs.shape:
n *= dim
iptr = vecutil.numpy2pointer(idxs)
nptr = vecutil.numpy2pointer(normals)
vptr = vecutil.numpy2pointer(points)
cptr = vecutil.numpy2pointer(colors)
mode = self.ui.fillmodes[self.ui.fillmode]
gl.glPolygonMode( gl.GL_FRONT, mode )
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_NORMAL_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vptr)
gl.glNormalPointer( gl.GL_FLOAT, 0, nptr)
gl.glColorPointer(3, gl.GL_FLOAT, 0, cptr)
gl.glDrawElements(gl.gl.GL_TRIANGLES, n, gl.GL_UNSIGNED_INT, iptr)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_NORMAL_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glPolygonMode( gl.GL_FRONT, gl.GL_FILL )
def __init__(self):
pts = generate_cyl_points().T
colors = np.zeros_like(pts)
colors[:,1]=1.0 # all green
n_pts = len(pts)
pts = map(float,pts.flat) # convert to flat list of floats
colors = map(float, colors.flat)
# Create ctypes arrays of the lists
vertices = (gl.GLfloat * (n_pts*3))(*pts)
colors = (gl.GLfloat * (n_pts*3))(*colors)
# Create a list of triangle indices.
indices = range(n_pts)
indices = (gl.GLuint * n_pts)(*indices)
# Compile a display list
self.list = gl.glGenLists(1)
gl.glNewList(self.list, gl.GL_COMPILE)
gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glColorPointer(3, gl.GL_FLOAT, 0, colors)
gl.glDrawElements(gl.GL_LINES, len(indices), gl.GL_UNSIGNED_INT, indices)
gl.glPopClientAttrib()
gl.glEndList()
def draw_bounding_box(self, x, y, screen_height):
bb = self.get_bounding_box()
bb = [bb['min_x'], bb['min_y'], bb['max_x'], bb['max_y']]
vertices = ()
for _ in bb:
vertices += (_.x,)
vertices += (screen_height - _.y,)
# get opengl vertices of type GLfloat
vertices_gl = (GLfloat * len(vertices))(*vertices)
# set the color
glColor4ub(0, 255, 0, 255);
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
# turn on blend for alpha channel
glEnable(GL_BLEND)
# tell open GL were passing a vertex array
glEnableClientState(GL_VERTEX_ARRAY)
# create a pointer to vertices_gl
glVertexPointer(2, GL_FLOAT, 0, vertices_gl)
# draw the array
glDrawArrays(GL_POLYGON, 0, len(vertices) // 2)
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
def _draw_rects(shape_list, vertex_vbo_id, texture_coord_vbo_id):
"""
Draw a set of rectangles using vertex buffers. This is more efficient
than drawing them individually.
"""
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)
GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST)
# GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
# GL.glMatrixMode(GL.GL_MODELVIEW)
# GL.glDisable(GL.GL_BLEND)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_vbo_id)
GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
GL.glEnableClientState(GL.GL_VERTEX_ARRAY)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, texture_coord_vbo_id)
offset = 0
for shape in shape_list:
if shape.can_cache:
texture_coord_vbo_id = None
GL.glColor4f(1, 1, 1, shape.alpha)
_render_rect_filled(shape, offset,
shape.texture.texture_id, texture_coord_vbo_id)
offset += 4
else:
shape.draw()
def update_display(verts, tex_coords, texture=bird_texture):
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_ALPHA_TEST)
gl.glAlphaFunc(gl.GL_GREATER, .1)
#gl.glEnable(gl.GL_BLEND)
#gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
n = len(verts[:])
#TODO verts._buffer.ctypes.data is awkward
gl.glVertexPointer(3, vert_dtype.gl, 0, verts[:].ctypes.data)
gl.glTexCoordPointer(3, tex_dtype.gl, 0, tex_coords[:].ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, n)
#unset state
gl.glPopAttrib()
gl.glDisable(texture.target)
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 drawArray(someArray):
# x = (ctypes.c_float * len(someArray))(*someArray[:][0])
# y = (ctypes.c_float * len(someArray))(*someArray[:][1])
# vertPoints = list(zip(x,y))
#someArray = np.array(someArray)
vertPoints = someArray[:, :2].flatten().astype(ctypes.c_float)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertPoints.ctypes.data)
gl.glDrawArrays(gl.GL_POINTS, 0, len(vertPoints) // 2)
def stripped_render(shape: VertexBuffer):
"""
Render an shape previously created with a ``create`` function.
Used by ``ShapeElementList.draw()`` for drawing several shapes in a batch.
"""
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_vertex_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def __init__(self, radius, inner_radius, slices, inner_slices):
# Create the vertex and normal arrays.
vertices = []
normals = []
u_step = 2 * math.pi / (slices - 1)
v_step = 2 * math.pi / (inner_slices - 1)
u = 0.
for i in range(slices):
cos_u = math.cos(u)
sin_u = math.sin(u)
v = 0.
for j in range(inner_slices):
cos_v = math.cos(v)
sin_v = math.sin(v)
d = (radius + inner_radius * cos_v)
x = d * cos_u
y = d * sin_u
z = inner_radius * sin_v
nx = cos_u * cos_v
ny = sin_u * cos_v
nz = sin_v
vertices.extend([x, y, z])
normals.extend([nx, ny, nz])
v += v_step
u += u_step
# Create ctypes arrays of the lists
vertices = (gl.GLfloat * len(vertices))(*vertices)
normals = (gl.GLfloat * len(normals))(*normals)
# Create a list of triangle indices.
indices = []
for i in range(slices - 1):
for j in range(inner_slices - 1):
p = i * inner_slices + j
indices.extend([p, p + inner_slices, p + inner_slices + 1])
indices.extend([p, p + inner_slices + 1, p + 1])
indices = (gl.GLuint * len(indices))(*indices)
# Compile a display list
self.list = gl.glGenLists(1)
gl.glNewList(self.list, gl.GL_COMPILE)
gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_NORMAL_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)
gl.glNormalPointer(gl.GL_FLOAT, 0, normals)
gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,
indices)
gl.glPopClientAttrib()
gl.glEndList()
def __init__(self, radius, inner_radius, slices, inner_slices):
# Create the vertex and normal arrays.
vertices = []
normals = []
u_step = 2 * pi / (slices - 1)
v_step = 2 * pi / (inner_slices - 1)
u = 0.
for i in range(slices):
cos_u = cos(u)
sin_u = sin(u)
v = 0.
for j in range(inner_slices):
cos_v = cos(v)
sin_v = sin(v)
d = (radius + inner_radius * cos_v)
x = d * cos_u
y = d * sin_u
z = inner_radius * sin_v
nx = cos_u * cos_v
ny = sin_u * cos_v
nz = sin_v
vertices.extend([x, y, z])
normals.extend([nx, ny, nz])
v += v_step
u += u_step
# Create ctypes arrays of the lists
vertices = (GLfloat * len(vertices))(*vertices)
normals = (GLfloat * len(normals))(*normals)
# Create a list of triangle indices.
indices = []
for i in range(slices - 1):
for j in range(inner_slices - 1):
p = i * inner_slices + j
indices.extend([p, p + inner_slices, p + inner_slices + 1])
indices.extend([p, p + inner_slices + 1, p + 1])
indices = (GLuint * len(indices))(*indices)
# Compile a display list
self.list = glGenLists(1)
glNewList(self.list, GL_COMPILE)
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_NORMAL_ARRAY)
glVertexPointer(3, GL_FLOAT, 0, vertices)
glNormalPointer(GL_FLOAT, 0, normals)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, indices)
glPopClientAttrib()
glEndList()
def render(shape):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, None)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_color_id)
gl.glColorPointer(4, gl.GL_FLOAT, 0, None)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def stripped_render_with_colors(shape: VertexBuffer):
"""
Render an shape previously created with a ``create`` function.
Used by ``ShapeElementList.draw()`` for drawing several shapes in a batch.
This version also assumes there is a color list as part of the VBO.
"""
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_vertex_id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, None)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_color_id)
gl.glColorPointer(4, gl.GL_FLOAT, 0, None)
gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def draw(self):
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable (gl.GL_BLEND)
gl.glEnable (gl.GL_LINE_SMOOTH);
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
#TODO verts._buffer.ctypes.data is awkward
gl.glVertexPointer(2, self.vert_dtype.gl, 0, self.verts._buffer.ctypes.data)
gl.glColorPointer(3, self.color_dtype.gl, 0, self.colors._buffer.ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, len(self.verts._buffer)//2)
def draw_fallback(self):
"""Called instead of :meth:`draw` when quads are used instead of
Point Sprite.
"""
self.make_delta_pos_to_vertex()
self.update_vertexs_from_pos()
self.update_per_vertex_colors()
gl.glPushMatrix()
self.transform()
# color preserve - at least intel 945G needs that
gl.glPushAttrib(gl.GL_CURRENT_BIT)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture.id)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
vertexs_ptr = PointerToNumpy(self.vertexs)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertexs_ptr)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
color_ptr = PointerToNumpy(self.per_vertex_colors)
# gl.glColorPointer(4, gl.GL_UNSIGNED_BYTE, 0, color_ptr)
gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
tex_coord_ptr = PointerToNumpy(self.tex_coords)
gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, tex_coord_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)
gl.glDrawArrays(gl.GL_QUADS, 0, len(self.vertexs) * 4)
# un -blend
gl.glPopAttrib()
# color restore
gl.glPopAttrib()
# disable states
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisable(gl.GL_TEXTURE_2D)
gl.glPopMatrix()
def draw_fallback(self):
"""Called instead of :meth:`draw` when quads are used instead of
Point Sprite.
"""
self.make_delta_pos_to_vertex()
self.update_vertexs_from_pos()
self.update_per_vertex_colors()
gl.glPushMatrix()
self.transform()
# color preserve - at least intel 945G needs that
gl.glPushAttrib(gl.GL_CURRENT_BIT)
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture.id)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
vertexs_ptr = PointerToNumpy(self.vertexs)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertexs_ptr)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
color_ptr = PointerToNumpy(self.per_vertex_colors)
# gl.glColorPointer(4, gl.GL_UNSIGNED_BYTE, 0, color_ptr)
gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
tex_coord_ptr = PointerToNumpy(self.tex_coords)
gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, tex_coord_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)
gl.glDrawArrays(gl.GL_QUADS, 0, len(self.vertexs) * 4)
# un -blend
gl.glPopAttrib()
# color restore
gl.glPopAttrib()
# disable states
gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisable(gl.GL_TEXTURE_2D)
gl.glPopMatrix()
def update_display(render_verts, colors):
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
n = len(render_verts[:])
# TODO verts._buffer.ctypes.data is awkward
gl.glVertexPointer(3, vert_dtype.gl, 0, render_verts[:].ctypes.data)
gl.glColorPointer(3, color_dtype.gl, 0, colors[:].ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, n)
def update_display(render_verts, colors):
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
n = len(render_verts[:])
#TODO verts._buffer.ctypes.data is awkward
gl.glVertexPointer(3, vert_dtype.gl, 0, render_verts[:].ctypes.data)
gl.glColorPointer(3, color_dtype.gl, 0, colors[:].ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, n)
def render_rect_filled(shape, x, y):
""" Render the shape at the right spot. """
# Set color
GL.glDisable(GL.GL_BLEND)
GL.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, shape.vbo_id)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glLoadIdentity()
GL.glTranslatef(x + shape.width / 2, y + shape.height / 2, 0)
GL.glDrawArrays(GL.GL_QUADS, 0, shape.size)
def render_points(self):
renderPoints = []
for point in self.points:
renderPoints.extend(point.position.vector)
self.ctPoints = (gl.GLfloat * len(renderPoints))(*renderPoints)
point_ptr = ct.cast(self.ctPoints, ct.c_void_p)
gl.glColor3f(1.0, 1.0, 1.0)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_ptr)
gl.glDrawArrays(gl.GL_POINTS, 0, len(renderPoints)//2)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def draw(verts,colors):
'''draw the numpy arrays `verts` and `colors`.'''
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable (gl.GL_BLEND)
gl.glEnable (gl.GL_LINE_SMOOTH);
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointer(2, vert_dtype.gl_type, 0, verts.ctypes.data)
gl.glColorPointer(3, color_dtype.gl_type, 0, colors.ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, len(verts)//2)
fps_display.draw()
def draw(verts, colors):
'''draw the numpy arrays `verts` and `colors`.'''
gl.glClearColor(0.2, 0.4, 0.5, 1.0)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glVertexPointer(2, vert_dtype.gl_type, 0, verts.ctypes.data)
gl.glColorPointer(3, color_dtype.gl_type, 0, colors.ctypes.data)
gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, len(verts) // 2)
fps_display.draw()
def drawlines( self, verts, colors, idxs ):
'helper to draw lines from numpy arrays of verts/colors/indexes'
vptr = vecutil.numpy2pointer(verts)
iptr = vecutil.numpy2pointer(idxs)
if colors is not None:
cptr = vecutil.numpy2pointer(colors)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glColorPointer(3, gl.GL_FLOAT, 0, cptr)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vptr)
gl.glDrawElements(gl.GL_LINES, len(idxs), gl.GL_UNSIGNED_INT, iptr)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
def render_road(self):
if self.initialized < 3:
vertices = []
colors = []
def vert(a, b, c):
for v in (a, b, c):
vertices.append(v)
for c in color:
colors.append(c)
color = (0.4, 0.8, 0.4, 1.0)
vert(-PLAYFIELD, +PLAYFIELD, 0)
vert(+PLAYFIELD, +PLAYFIELD, 0)
vert(+PLAYFIELD, -PLAYFIELD, 0)
vert(-PLAYFIELD, -PLAYFIELD, 0)
color = (0.4, 0.9, 0.4, 1.0)
k = PLAYFIELD / 20.0
for x in range(-20, 20, 2):
for y in range(-20, 20, 2):
vert(k * x + k, k * y + 0, 0)
vert(k * x + 0, k * y + 0, 0)
vert(k * x + 0, k * y + k, 0)
vert(k * x + k, k * y + k, 0)
for poly, col in self.road_poly:
color = (col[0], col[1], col[2], 1)
for p in poly:
vert(p[0], p[1], 0)
self.initialized += 1
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl_vertices = (gl.GLfloat * len(vertices))(*vertices)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER_ARB, self.vertex_vbo_id)
gl.glBufferData(gl.GL_ARRAY_BUFFER_ARB,
len(vertices) * 4, gl_vertices, gl.GL_STATIC_DRAW)
gl_colors = (gl.GLfloat * len(colors))(*colors)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER_ARB, self.color_vbo_id)
gl.glBufferData(gl.GL_ARRAY_BUFFER_ARB,
len(colors) * 4, gl_colors, gl.GL_STATIC_DRAW)
self.numdraw = len(vertices) // 3
gl.glBindBuffer(gl.GL_ARRAY_BUFFER_ARB, self.vertex_vbo_id)
gl.glVertexPointer(3, gl.GL_FLOAT, 0, 0)
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER_ARB, self.color_vbo_id)
gl.glColorPointer(4, gl.GL_FLOAT, 0, 0)
gl.glDrawArrays(gl.GL_QUADS, 0, self.numdraw)
def _display_travels(self, has_vbo):
self.travel_buffer.bind()
glVertexPointer(3, GL_FLOAT, 0, self.travel_buffer.ptr)
# Prevent race condition by using the number of currently loaded layers
max_layers = self.layers_loaded
# TODO: show current layer travels in a different color
end = self.layer_stops[min(self.num_layers_to_draw, max_layers)]
end_index = self.count_travel_indices[end]
glColor4f(*self.color_travel)
if self.only_current:
if self.num_layers_to_draw < max_layers:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
start_index = self.count_travel_indices[end_prev_layer + 1]
glDrawArrays(GL_LINES, start_index, end_index - start_index + 1)
else:
glDrawArrays(GL_LINES, 0, end_index)
self.travel_buffer.unbind()
def _display_travels(self, has_vbo):
self.travel_buffer.bind()
glVertexPointer(3, GL_FLOAT, 0, self.travel_buffer.ptr)
# Prevent race condition by using the number of currently loaded layers
max_layers = self.layers_loaded
# TODO: show current layer travels in a different color
end = self.layer_stops[min(self.num_layers_to_draw, max_layers)]
end_index = self.count_travel_indices[end]
glColor4f(*self.color_travel)
if self.only_current:
if self.num_layers_to_draw < max_layers:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
start_index = self.count_travel_indices[end_prev_layer + 1]
glDrawArrays(GL_LINES, start_index,
end_index - start_index + 1)
else:
glDrawArrays(GL_LINES, 0, end_index)
self.travel_buffer.unbind()
def draw(self, offset_x, offset_y, screen_height):
vertices = self.get_screen_relative_vertices(offset_x, offset_y, screen_height)
# get opengl vertices of type GLfloat
vertices_gl = (GLfloat * len(vertices))(*vertices)
# set the color
glColor4ub(*self.color);
# turn on blend for alpha channel
glEnable(GL_BLEND)
# tell open GL were passing a vertex array
glEnableClientState(GL_VERTEX_ARRAY)
# create a pointer to vertices_gl
glVertexPointer(2, GL_FLOAT, 0, vertices_gl)
# draw the array
glDrawArrays(GL_POLYGON, 0, len(vertices) // 2)
def on_draw(self):
"""
Render the screen.
"""
# This command has to happen before we start drawing
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glLoadIdentity()
gl.glTranslatef(self.center_x, self.center_y, 0)
for shape in self.shape_list:
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_id)
gl.glDrawArrays(gl.GL_QUADS, 0, shape.size)
gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
def _display_travels(self, has_vbo):
self.travel_buffer.bind()
if has_vbo:
glVertexPointer(3, GL_FLOAT, 0, None)
else:
glVertexPointer(3, GL_FLOAT, 0, self.travel_buffer.ptr)
# TODO: show current layer travels in a different color
end = self.layer_stops[min(self.num_layers_to_draw, self.max_layers)]
end_index = self.count_travel_indices[end]
glColor4f(*self.color_travel)
if self.only_current:
if self.num_layers_to_draw < self.max_layers:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
start_index = self.count_travel_indices[end_prev_layer + 1]
glDrawArrays(GL_LINES, start_index, end_index - start_index + 1)
else:
glDrawArrays(GL_LINES, 0, end_index)
self.travel_buffer.unbind()
def _draw_rects(shape_list: Iterable[Sprite], vertex_vbo_id: gl.GLuint,
texture_coord_vbo_id: gl.GLuint):
"""
Draw a set of rectangles using vertex buffers. This is more efficient
than drawing them individually.
"""
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_TEXTURE_2D) # As soon as this happens, can't use drawing commands
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
# gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# gl.glMatrixMode(gl.GL_MODELVIEW)
# gl.glDisable(gl.GL_BLEND)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id)
offset = 0
for shape in shape_list:
if shape.can_cache:
texture_coord_vbo_id = None
gl.glColor4f(1, 1, 1, shape.alpha)
_render_rect_filled(shape, offset,
shape.texture.texture_id, texture_coord_vbo_id)
offset += 4
else:
shape.draw()
gl.glDisable(gl.GL_TEXTURE_2D)
def draw_arrays(primitive, verts=None, colors=None, tc0=None, tc1=None, tc2=None, tc3=None):
states = []
if verts is not None:
verts = ascont(verts)
assert verts.ndim >= 2 and verts.shape[-1] <= 4
gl.glVertexPointer( verts.shape[-1], arrayToGLType(verts), verts.strides[-2], verts.ctypes.data)
states.append( gl.GL_VERTEX_ARRAY )
if colors is not None:
colors = ascont(colors)
gl.glColorPointer( colors.shape[-1], arrayToGLType(colors), colors.strides[-2], colors.ctypes.data)
states.append( gl.GL_COLOR_ARRAY )
protect = []
for i, tc in enumerate([tc0, tc1, tc2, tc3]):
if tc is not None:
tc = ascont(tc)
protect.append(tc)
gl.glClientActiveTexture(GL_TEXTURE0 + i)
gl.glTexCoordPointer(tc.shape[-1], arrayToGLType(tc), tc.strides[-2], tc.ctypes.data)
states.append( (GL_TEXTURE_COORD_ARRAY, i) )
with glstate(*states):
gl.glDrawArrays( primitive, 0, np.prod(verts.shape[:-1]) )
def _draw_rects(shape_list: Iterable[Sprite], vertex_vbo_id: gl.GLuint,
texture_coord_vbo_id: gl.GLuint):
"""
Draw a set of rectangles using vertex buffers. This is more efficient
than drawing them individually.
"""
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_TEXTURE_2D
) # As soon as this happens, can't use drawing commands
gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
# gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# gl.glMatrixMode(gl.GL_MODELVIEW)
# gl.glDisable(gl.GL_BLEND)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id)
offset = 0
for shape in shape_list:
if shape.can_cache:
texture_coord_vbo_id = None
gl.glColor4f(1, 1, 1, shape.alpha)
_render_rect_filled(shape, offset, shape.texture.texture_id,
texture_coord_vbo_id)
offset += 4
else:
shape.draw()
gl.glDisable(gl.GL_TEXTURE_2D)
def draw_background(self):
varray = []
carray = []
x = self.top_left['x']
y = self.top_left['y']
for _ in self.background:
basePosition = _[0]
depth = _[1]
color = _[2]
#parallax scrolling and wrapping
realPosition = (basePosition[0] + x * depth, basePosition[1] + y * depth)
wrappedPosition = ( realPosition[0] % self.background_width, realPosition[1] % self.background_height)
varray += [wrappedPosition[0], wrappedPosition[1], 0]
carray += color
# # # needs to be commented and understood..
# glEnable(GL_BLEND)
# glEnable(GL_VERTEX_PROGRAM_POINT_SIZE)
# point_size = GLfloat(10.0)
# glGetFloatv(GL_POINT_SIZE_MAX_ARB, point_size)
# glPointSize(point_size)
# glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, (GLfloat * 3)(0, 0, 5))
# glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 5)
varray = (GLfloat * len(varray))(*varray)
carray = (GLfloat * len(carray))(*carray)
glVertexPointer(3, GL_FLOAT, 0, varray)
glColorPointer(4, GL_FLOAT, 0, carray)
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
glDrawArrays(GL_POINTS, 0, len(varray)//3)
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
def render_rectangle_filled(shape, center_x, center_y, color, tilt_angle=0):
"""
Render a rectangle previously created by the ``create_rectangle`` command.
"""
# Set color
if len(color) == 4:
GL.glColor4ub(shape.color[0], shape.color[1], shape.color[2],
shape.color[3])
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
elif len(color) == 3:
GL.glDisable(GL.GL_BLEND)
GL.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, shape.vbo_id)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glLoadIdentity()
GL.glTranslatef(center_x + shape.width / 2, center_y + shape.height / 2, 0)
if tilt_angle != 0:
GL.glRotatef(tilt_angle, 0, 0, 1)
GL.glDrawArrays(GL.GL_QUADS, 0, shape.size)
def render_ellipse_filled(shape, center_x, center_y, color, angle=0):
"""
Render an ellipse previously created with the ``create_ellipse`` function.
"""
# Set color
if len(color) == 4:
GL.glColor4ub(shape.color[0], shape.color[1], shape.color[2],
shape.color[3])
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
elif len(color) == 3:
GL.glDisable(GL.GL_BLEND)
GL.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, shape.vbo_id)
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0)
GL.glLoadIdentity()
GL.glTranslatef(center_x, center_y, 0)
if angle:
GL.glRotatef(angle, 0, 0, 1)
GL.glDrawArrays(GL.GL_TRIANGLE_FAN, 0, shape.size)
def render_bounding_box(self):
gl.glLineWidth(1.0)
self.ctPoints = self.ctPointT(
self.rect.min.x, self.rect.min.y,
self.rect.max.x, self.rect.min.y,
self.rect.max.x, self.rect.min.y,
self.rect.max.x, self.rect.max.y,
self.rect.max.x, self.rect.max.y,
self.rect.min.x, self.rect.max.y,
self.rect.min.x, self.rect.max.y,
self.rect.min.x, self.rect.min.y,
)
point_ptr = ct.cast(self.ctPoints, ct.c_void_p)
gl.glColor3f(*self.bbColor)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_ptr)
gl.glDrawArrays(gl.GL_LINES, 0, 8)
gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def paintGL(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glLoadIdentity()
#draw lines
gl.glEnableClientState(gl.GL_COLOR_ARRAY)
self.lineVerts = (self.spl.segments + self.centre).flatten()
self.lineVerts_gl = (gl.GLfloat * len(self.lineVerts))(*self.lineVerts)
self.lineColors = (self.spl.segColor).flatten()
self.lineColors_gl = (gl.GLfloat *
len(self.lineColors))(*self.lineColors)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, self.lineVerts_gl)
gl.glColorPointer(4, gl.GL_FLOAT, 0, self.lineColors_gl)
gl.glDrawArrays(gl.GL_LINES, 0, len(self.lineVerts) // 2)
gl.glDisableClientState(gl.GL_COLOR_ARRAY)
#draw points
gl.glColor3f(1.0, 1.0, 1.0)
vertPoints = (self.spl.state[:, :2] + self.centre).flatten().astype(
ctypes.c_float)
vertices_gl = vertPoints.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertices_gl)
gl.glDrawArrays(gl.GL_POINTS, 0, len(vertPoints) // 2)
#overdraw selected point
if self.spl.clicked != -1:
gl.glColor3f(1.0, 0.0, 0.0)
point = (self.spl.clickedState[:2] + self.centre).astype(
ctypes.c_float)
point_gl = point.ctypes.data_as(ctypes.POINTER(ctypes.c_float))
gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_gl)
gl.glDrawArrays(gl.GL_POINTS, 0, 1)
pyglet.text.Label("Epoch: %s" % self.secStruct.epochCount,
x=5,
y=10,
font_name='Times New Roman',
font_size=20).draw()
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 _display_movements(self, mode_2d=False):
self.vertex_buffer.bind()
has_vbo = isinstance(self.vertex_buffer, VertexBufferObject)
if has_vbo:
glVertexPointer(3, GL_FLOAT, 0, None)
else:
glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr)
self.vertex_color_buffer.bind()
if has_vbo:
glColorPointer(4, GL_FLOAT, 0, None)
else:
glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr)
start = 0
if self.num_layers_to_draw <= self.max_layers:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
else:
end_prev_layer = -1
end = self.layer_stops[min(self.num_layers_to_draw, self.max_layers)]
glDisableClientState(GL_COLOR_ARRAY)
glColor4f(*self.color_printed)
# Draw printed stuff until end or end_prev_layer
cur_end = min(self.printed_until, end)
if not self.only_current:
if 0 <= end_prev_layer <= cur_end:
glDrawArrays(GL_LINES, start, end_prev_layer)
elif cur_end >= 0:
glDrawArrays(GL_LINES, start, cur_end)
glEnableClientState(GL_COLOR_ARRAY)
# Draw nonprinted stuff until end_prev_layer
start = max(cur_end, 0)
if end_prev_layer >= start:
if not self.only_current:
glDrawArrays(GL_LINES, start, end_prev_layer - start)
cur_end = end_prev_layer
# Draw current layer
if end_prev_layer >= 0:
glDisableClientState(GL_COLOR_ARRAY)
# Backup & increase line width
orig_linewidth = (GLfloat)()
glGetFloatv(GL_LINE_WIDTH, orig_linewidth)
glLineWidth(2.0)
glColor4f(*self.color_current_printed)
if cur_end > end_prev_layer:
glDrawArrays(GL_LINES, end_prev_layer, cur_end - end_prev_layer)
glColor4f(*self.color_current)
if end > cur_end:
glDrawArrays(GL_LINES, cur_end, end - cur_end)
# Restore line width
glLineWidth(orig_linewidth)
glEnableClientState(GL_COLOR_ARRAY)
# Draw non printed stuff until end (if not ending at a given layer)
start = max(self.printed_until, 0)
end = end - start
if end_prev_layer < 0 and end > 0 and not self.only_current:
glDrawArrays(GL_LINES, start, end)
self.vertex_buffer.unbind()
self.vertex_color_buffer.unbind()
def _display_movements(self, has_vbo):
self.vertex_buffer.bind()
if has_vbo:
glVertexPointer(3, GL_FLOAT, 0, None)
else:
glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr)
self.vertex_color_buffer.bind()
if has_vbo:
glColorPointer(4, GL_FLOAT, 0, None)
else:
glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr)
self.index_buffer.bind()
start = 1
layer_selected = self.num_layers_to_draw <= self.max_layers
if layer_selected:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
else:
end_prev_layer = 0
end = self.layer_stops[min(self.num_layers_to_draw, self.max_layers)]
glDisableClientState(GL_COLOR_ARRAY)
glColor4f(*self.color_printed)
# Draw printed stuff until end or end_prev_layer
cur_end = min(self.printed_until, end)
if not self.only_current:
if 1 <= end_prev_layer <= cur_end:
self._draw_elements(1, end_prev_layer)
elif cur_end >= 1:
self._draw_elements(1, cur_end)
glEnableClientState(GL_COLOR_ARRAY)
# Draw nonprinted stuff until end_prev_layer
start = max(cur_end, 1)
if end_prev_layer >= start:
if not self.only_current:
self._draw_elements(start, end_prev_layer)
cur_end = end_prev_layer
# Draw current layer
if layer_selected:
glDisableClientState(GL_COLOR_ARRAY)
# Backup & increase line width
orig_linewidth = (GLfloat)()
glGetFloatv(GL_LINE_WIDTH, orig_linewidth)
glLineWidth(2.0)
glColor4f(*self.color_current_printed)
if cur_end > end_prev_layer:
self._draw_elements(end_prev_layer + 1, cur_end)
glColor4f(*self.color_current)
if end > cur_end:
self._draw_elements(cur_end + 1, end)
# Restore line width
glLineWidth(orig_linewidth)
glEnableClientState(GL_COLOR_ARRAY)
# Draw non printed stuff until end (if not ending at a given layer)
start = max(self.printed_until, 1)
if not layer_selected and end >= start:
self._draw_elements(start, end)
self.vertex_buffer.unbind()
self.vertex_color_buffer.unbind()
def drawArray(someArray): vertPoints = someArray[:, :2].flatten().astype(ctypes.c_float) gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertPoints.ctypes.data) gl.glDrawArrays(gl.GL_POINTS, 0, len(vertPoints) // 2)
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()
def _display_movements(self, has_vbo):
self.vertex_buffer.bind()
glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr)
self.vertex_color_buffer.bind()
glColorPointer(3, GL_FLOAT, 0, self.vertex_color_buffer.ptr)
self.vertex_normal_buffer.bind()
glNormalPointer(GL_FLOAT, 0, self.vertex_normal_buffer.ptr)
self.index_buffer.bind()
# Prevent race condition by using the number of currently loaded layers
max_layers = self.layers_loaded
start = 1
layer_selected = self.num_layers_to_draw <= max_layers
if layer_selected:
end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1]
else:
end_prev_layer = 0
end = self.layer_stops[min(self.num_layers_to_draw, max_layers)]
glDisableClientState(GL_COLOR_ARRAY)
glColor3f(*self.color_printed[:-1])
# Draw printed stuff until end or end_prev_layer
cur_end = min(self.printed_until, end)
if not self.only_current:
if 1 <= end_prev_layer <= cur_end:
self._draw_elements(1, end_prev_layer)
elif cur_end >= 1:
self._draw_elements(1, cur_end)
glEnableClientState(GL_COLOR_ARRAY)
# Draw nonprinted stuff until end_prev_layer
start = max(cur_end, 1)
if end_prev_layer >= start:
if not self.only_current:
self._draw_elements(start, end_prev_layer)
cur_end = end_prev_layer
# Draw current layer
if layer_selected:
glDisableClientState(GL_COLOR_ARRAY)
glColor3f(*self.color_current_printed[:-1])
if cur_end > end_prev_layer:
self._draw_elements(end_prev_layer + 1, cur_end)
glColor3f(*self.color_current[:-1])
if end > cur_end:
self._draw_elements(cur_end + 1, end)
glEnableClientState(GL_COLOR_ARRAY)
# Draw non printed stuff until end (if not ending at a given layer)
start = max(self.printed_until, 1)
if not layer_selected and end >= start:
self._draw_elements(start, end)
self.index_buffer.unbind()
self.vertex_buffer.unbind()
self.vertex_color_buffer.unbind()
self.vertex_normal_buffer.unbind()
def bind(self):
gl.glEnableClientState(self.type)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.id)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
def drawVertexbuffers(vertexBuffer, *args, mode=GL.GL_TRIANGLES, flush=True):
"""Draw a vertex buffer using glDrawArrays. This method does not require
shaders.
Parameters
----------
vertexBuffer : :obj:`Vertexbuffer`
Vertex buffer descriptor, must have 'bufferType' as GL_VERTEX_ARRAY.
Optional vertex buffer descriptors can be passed as seperate arguments,
they must have 'bufferTypes' as GL_TEXTURE_COORD_ARRAY, GL_NORMAL_ARRAY
or GL_COLOR_ARRAY.
mode : :obj:`int`
Drawing mode to use (e.g. GL_TRIANGLES, GL_QUADS, GL_POINTS, etc.)
flush : :obj:`bool`
Flush queued drawing commands before returning.
Returns
-------
None
Examples
--------
# vertices of a triangle
verts = [ 1.0, 1.0, 0.0, # v0
0.0, -1.0, 0.0, # v1
-1.0, 1.0, 0.0] # v2
# triangle vertex colors
colors = [1.0, 0.0, 0.0, # v0
0.0, 1.0, 0.0, # v1
0.0, 0.0, 1.0] # v2
# load vertices to graphics device, return a descriptor
vertexBuffer = createVertexbuffer(verts, 3)
colorBuffer = createVertexbuffer(c, 3, GL.GL_COLOR_ARRAY)
# draw the VBO
drawVertexbuffer(vertexBuffer, colorBuffer, GL.GL_TRIANGLES)
"""
# must have a vertex pointer
assert vertexBuffer.bufferType == GL.GL_VERTEX_ARRAY
# bind and set the vertex pointer
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBuffer.id)
GL.glVertexPointer(vertexBuffer.vertexSize, vertexBuffer.dtype, 0, None)
GL.glEnableClientState(vertexBuffer.bufferType)
# handle additional buffers
if args:
for buffer in args:
# check if the number of indicies are the same
if vertexBuffer.indices != buffer.indices:
raise RuntimeError("Vertex buffer indices do not match!")
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, buffer.id)
if buffer.bufferType == GL.GL_TEXTURE_COORD_ARRAY:
GL.glTexCoordPointer(buffer.dtype, 0, None)
elif buffer.bufferType == GL.GL_NORMAL_ARRAY:
GL.glNormalPointer(buffer.dtype, 0, None)
elif buffer.bufferType == GL.GL_COLOR_ARRAY:
GL.glColorPointer(buffer.vertexSize, buffer.dtype, 0, None)
GL.glEnableClientState(buffer.bufferType)
GL.glDrawArrays(mode, 0, vertexBuffer.indices) # draw arrays
# reset
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
GL.glDisableClientState(vertexBuffer.bufferType)
if args:
for vbo in args:
GL.glDisableClientState(vbo.bufferType)
if flush:
GL.glFlush()
def render(self, scene):
""" Add a ring to the view.
:param scene: The view to render the model into
:type scene: pyglet_helper.objects.View
"""
if self.degenerate:
return
# The number of subdivisions around the hoop's radial direction.
if self.thickness:
band_coverage = scene.pixel_coverage(self.pos, self.thickness)
else:
band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)
if band_coverage < 0:
band_coverage = 1000
bands = sqrt(band_coverage * 4.0)
bands = clamp(4, bands, 40)
# The number of subdivisions around the hoop's tangential direction.
ring_coverage = scene.pixel_coverage(self.pos, self.radius)
if ring_coverage < 0:
ring_coverage = 1000
rings = sqrt(ring_coverage * 4.0)
rings = clamp(4, rings, 80)
slices = int(rings)
inner_slices = int(bands)
radius = self.radius
inner_radius = self.thickness
# Create the vertex and normal arrays.
vertices = []
normals = []
outer_angle_step = 2 * pi / (slices - 1)
inner_angle_step = 2 * pi / (inner_slices - 1)
outer_angle = 0.
for i in range(slices):
cos_outer_angle = cos(outer_angle)
sin_outer_angle = sin(outer_angle)
inner_angle = 0.
for j in range(inner_slices):
cos_inner_angle = cos(inner_angle)
sin_inner_angle = sin(inner_angle)
diameter = (radius + inner_radius * cos_inner_angle)
vertex_x = diameter * cos_outer_angle
vertex_y = diameter * sin_outer_angle
vertex_z = inner_radius * sin_inner_angle
normal_x = cos_outer_angle * cos_inner_angle
normal_y = sin_outer_angle * cos_inner_angle
normal_z = sin_inner_angle
vertices.extend([vertex_x, vertex_y, vertex_z])
normals.extend([normal_x, normal_y, normal_z])
inner_angle += inner_angle_step
outer_angle += outer_angle_step
# Create ctypes arrays of the lists
vertices = (gl.GLfloat *len(vertices))(*vertices)
normals = (gl.GLfloat * len(normals))(*normals)
# Create a list of triangle indices.
indices = []
for i in range(slices - 1):
for j in range(inner_slices - 1):
pos = i * inner_slices + j
indices.extend([pos, pos + inner_slices, pos + inner_slices +
1])
indices.extend([pos, pos + inner_slices + 1, pos + 1])
indices = (gl.GLuint * len(indices))(*indices)
# Compile a display list
self.list = gl.glGenLists(1)
gl.glNewList(self.list, gl.GL_COMPILE)
self.color.gl_set(self.opacity)
gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glEnableClientState(gl.GL_NORMAL_ARRAY)
self.model_world_transform(scene.gcf,
Vector([self.radius, self.radius,
self.radius])).gl_mult()
gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)
gl.glNormalPointer(gl.GL_FLOAT, 0, normals)
gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,
indices)
gl.glPopClientAttrib()
gl.glEndList()
gl.glCallList(self.list)
def vertex(self):
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffers["vertex"])
gl.glVertexPointer(3, gl.GL_FLOAT, 0, 0)
def _draw_rects(shape_list: List[Sprite], vertex_vbo_id: gl.GLuint,
texture_coord_vbo_id: gl.GLuint, change_x: float,
change_y: float):
"""
Draw a set of rectangles using vertex buffers. This is more efficient
than drawing them individually.
"""
if len(shape_list) == 0:
return
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_TEXTURE_2D
) # As soon as this happens, can't use drawing commands
# gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
# gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST)
# gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# gl.glMatrixMode(gl.GL_MODELVIEW)
# gl.glDisable(gl.GL_BLEND)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id)
gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id)
last_alpha = shape_list[0].alpha
gl.glColor4f(1, 1, 1, last_alpha)
gl.glLoadIdentity()
# gl.glLoadIdentity()
gl.glTranslatef(change_x, change_y, 0)
# Ideally, we want to draw these in "batches."
# We seek to find groups of squares with the same texture. Then draw
# them all at once.
last_texture_id = None
last_alpha = 1
batch_count = 0
offset = 0
batch_offset = 0
texture_coord_vbo_id = None
for shape in shape_list:
if shape.texture.texture_id != last_texture_id or shape.alpha != last_alpha:
# Ok, if the 'if' triggered above, we are now looking at a different
# texture than we looked at with the last loop. So draw the last
# "batch" of squares. We'll start a new batch with the current
# square but not draw it yet
if batch_count > 0:
gl.glColor4f(1, 1, 1, last_alpha)
_render_rect_filled(batch_offset, last_texture_id,
texture_coord_vbo_id, batch_count)
batch_count = 0
batch_offset = offset
last_texture_id = shape.texture.texture_id
last_alpha = shape.alpha
batch_count += 4
offset += 4
# Draw the last batch, if it exists
_render_rect_filled(batch_offset, last_texture_id, texture_coord_vbo_id,
batch_count)
gl.glDisable(gl.GL_TEXTURE_2D)
def createVAO(vertexBuffer,
textureCoordBuffer=None,
normalBuffer=None,
colorBuffer=None):
"""Create a Vertex Array Object (VAO) with specified Vertex Buffer Objects.
VAOs store buffer binding states, reducing binding overhead when drawing
objects with vertext data stored in VBOs.
Parameters
----------
vertexBuffer : :obj:`VertexBufferObject`
Vertex buffer descriptor, must have 'bufferType' as GL_VERTEX_ARRAY.
textureCoordBuffer : :obj:`VertexBufferObject` or None, optional
Vertex buffer descriptor of texture coordinates, must have 'bufferType'
as GL_TEXTURE_COORD_ARRAY.
normalBuffer : :obj:`VertexBufferObject` or None, optional
Vertex buffer descriptor of normals, must have 'bufferType' as
GL_NORMAL_ARRAY.
colorBuffer :obj:`VertexBufferObject` or None, optional
Vertex buffer descriptor of colors, must have 'bufferType' as
GL_COLOR_ARRAY.
Returns
-------
VertexArrayObject
A descriptor with vertex buffer information.
Examples
--------
# create a VAO
vaoDesc = createVAO(vboVerts, vboTexCoords, vboNormals)
# draw the VAO, renders the mesh
drawVAO(vaoDesc, GL.GL_TRIANGLES)
"""
# create a vertex buffer ID
vaoId = GL.GLuint()
GL.glGenVertexArrays(1, ctypes.byref(vaoId))
GL.glBindVertexArray(vaoId)
# must have a vertex pointer
assert vertexBuffer.bufferType == GL.GL_VERTEX_ARRAY
# bind and set the vertex pointer, this is must be bound
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBuffer.id)
GL.glVertexPointer(vertexBuffer.vertexSize, vertexBuffer.dtype, 0, None)
GL.glEnableClientState(vertexBuffer.bufferType)
# texture coordinates
if textureCoordBuffer is not None:
if vertexBuffer.indices != textureCoordBuffer.indices:
raise RuntimeError(
"Texture and vertex buffer indices do not match!")
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, textureCoordBuffer.id)
GL.glTexCoordPointer(textureCoordBuffer.vertexSize,
textureCoordBuffer.dtype, 0, None)
GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY)
# normals
if normalBuffer is not None:
if vertexBuffer.indices != normalBuffer.indices:
raise RuntimeError(
"Normal and vertex buffer indices do not match!")
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, normalBuffer.id)
GL.glNormalPointer(normalBuffer.dtype, 0, None)
GL.glEnableClientState(GL.GL_NORMAL_ARRAY)
# colors
if colorBuffer is not None:
if vertexBuffer.indices != colorBuffer.indices:
raise RuntimeError("Color and vertex buffer indices do not match!")
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, colorBuffer.id)
GL.glColorPointer(colorBuffer.vertexSize, colorBuffer.dtype, 0, None)
GL.glEnableClientState(GL.GL_COLOR_ARRAY)
GL.glBindVertexArray(0)
return VertexArrayObject(vaoId, vertexBuffer.indices, dict())
