def draw_detector(self):
glUseProgram(self.shader)
try:
self.dom_positions_vbo.bind()
try:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.dom_positions_vbo)
glPointSize(2)
glDrawArrays(GL_POINTS, 0, len(self.dom_positions)*3)
finally:
self.dom_positions_vbo.unbind()
glDisableClientState(GL_VERTEX_ARRAY)
finally:
glUseProgram(0)
def draw(self):
glDisable(GL_LIGHTING)
glLineWidth(self._width)
glColor(*self._color)
glEnableClientState(GL_VERTEX_ARRAY)
if self._vbo:
with self._vbo:
glVertexPointerf(self._vbo)
glDrawArrays(GL_LINE_STRIP, 0, len(self._vbo))
glDisableClientState(GL_VERTEX_ARRAY)
glEnable(GL_LIGHTING)
def display(self):
self.world.drawGL()
glDisable(GL_LIGHTING)
glLineWidth(2.0)
glEnableClientState(GL_VERTEX_ARRAY)
for (color, vbo) in self.trace_vbos:
glColor(*color)
with vbo:
glVertexPointerf(vbo)
glDrawArrays(GL_LINE_STRIP, 0, len(vbo))
glDisableClientState(GL_VERTEX_ARRAY)
glEnable(GL_LIGHTING)
def paintGL(self):
"""
Drawing routing
"""
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
#Draw spiral in 'immediate mode'
#WARNING: You should not be doing the spiral calculation inside the loop
#even if you are using glBegin/glEnd, sin/cos are fairly expensive functions
#For now left here to make code simpler
radius = 1.0
x = radius * math.sin(0)
y = radius * math.cos(0)
glColor(0.0, 1.0, 0.0)
glBegin(GL_LINE_STRIP)
for deg in range(1000):
glVertex(x, y, 0.0)
rad = math.radians(deg)
radius -= 0.001
x = radius * math.sin(rad)
y = radius * math.cos(rad)
glEnd()
glEnableClientState(GL_VERTEX_ARRAY)
#TODO: Use list comprehension
spiral_array = []
#Second spiral using "array immediate mode" (i.e vertex arrays)
radius = 0.8
x = radius * math.sin(0)
y = radius * math.cos(0)
glColor(1.0, 0.0, 0.0)
for deg in range(820):
spiral_array.append([x, y])
rad = math.radians(deg)
radius -= 0.001
x = radius * math.sin(rad)
y = radius * math.cos(rad)
glVertexPointerf(spiral_array)
glDrawArrays(GL_LINE_STRIP, 0, len(spiral_array))
glFlush()
def draw_lines(ls):
glDisableClientState(GL_NORMAL_ARRAY)
glEnableClientState(GL_VERTEX_ARRAY)
glLineWidth(3.0)
allpts = ls.v[ls.e.flatten()].astype(np.float32)
glVertexPointerf(allpts)
if hasattr(ls, 'vc') or hasattr(ls, 'ec'):
glEnableClientState(GL_COLOR_ARRAY)
if hasattr(ls, 'vc'):
glColorPointerf(ls.vc[ls.e.flatten()].astype(np.float32))
else:
clrs = np.ones(
(ls.e.shape[0] * 2, 3)) * np.repeat(ls.ec, 2, axis=0)
glColorPointerf(clrs)
else:
glDisableClientState(GL_COLOR_ARRAY)
glDisable(GL_LIGHTING)
glDrawElementsui(GL_LINES, np.arange(len(allpts), dtype=np.uint32))
def render(self):
vertex = []
for vert, verts in enumerate(self.vertex):
vx = numpy.dot(self.vertex[vert], numpy.array([math.cos(math.radians(self.ss.r)),
math.sin(math.radians(self.ss.r)), 0,
-math.sin(math.radians(self.ss.r)),
math.cos(math.radians(self.ss.r)), 0,
0, 0, 1], 'f').reshape(3, 3))
vx = vx + numpy.array([self.ss.x + self.ss.ggci.player.x, self.ss.y + self.ss.ggci.player.y, 0 - self.ss.ggci.player.z], 'f').reshape(1, 3)
vertex.append(vx)
vertex = numpy.array(vertex, 'f').reshape(len(self.vertex), 3)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(vertex)
glDrawElementsui(GL_POLYGON, self.indices)
def draw(self):
'''
Draw the point cloud.
'''
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glMultMatrixf(self._pose.T)
glDisable(GL_LIGHTING)
glPointSize(2)
if self._xyz_vbo:
# ref: http://stackoverflow.com/questions/16558819/vertex-buffer-objects-in-pyopengl-vertex-index-and-colour
with self._xyz_vbo:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self._xyz_vbo)
if self._rgb_vbo:
# check for dimension match to avoid segmentation faults
if len(self._rgb_vbo) != len(self._xyz_vbo):
raise RuntimeError(
'point cloud XYZ and RGB length mismatch: {} vs {}'
.format(len(self._xyz_vbo), len(self._rgb_vbo)))
with self._rgb_vbo:
# add color
glEnableClientState(GL_COLOR_ARRAY)
glColorPointerf(self._rgb_vbo)
glDrawArrays(GL_POINTS, 0, len(self._xyz_vbo))
else:
# draw without color
glDrawArrays(GL_POINTS, 0, len(self._xyz_vbo))
glDisableClientState(GL_COLOR_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glEnable(GL_LIGHTING)
glPopMatrix()
def paint(self):
self._applyGLOptions()
if self.__antialiasing:
glEnable(GL_LINE_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
glLineWidth(1.5)
if self.draw_faces:
# need face
with self.shader_program:
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.mesh.face_vertices)
glColor4f(*self.face_color)
glEnableClientState(GL_NORMAL_ARRAY)
glNormalPointerf(self.mesh.face_normal_vectors)
glDrawArrays(GL_TRIANGLES, 0,
np.product(self.mesh.face_vertices.shape[:-1]))
glDisableClientState(GL_NORMAL_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
if self.debug_face_normals:
# Visualize the face normal vectors
glEnableClientState(GL_VERTEX_ARRAY)
N = self.mesh.face_vertices.shape[0] * 3
v = np.concatenate([
self.mesh.face_vertices,
self.mesh.face_vertices + self.mesh.face_normal_vectors,
])
e = np.array([np.arange(N), np.arange(N) + N]).T.flatten()
glColor4f(1.0, 1.0, 0.0, 1.0)
glVertexPointerf(v)
glDrawElements(GL_LINES, e.shape[0], GL_UNSIGNED_INT, e)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
if self.debug_face_edges:
# visualize all face edges
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.mesh.wireframe_vertices)
glColor4f(1.0, 1.0, 0.0, 1.0)
edges = self.mesh.face_edges.flatten()
glDrawElements(GL_LINES, edges.shape[0], GL_UNSIGNED_INT, edges)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
if self.draw_wireframe and self.mesh.has_wireframe:
# draw a mesh wireframe which may or may not be identical to the face edges, depending on the mesh
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointerf(self.mesh.wireframe_vertices)
glColor4f(0, 1, 0, 1)
edges = self.mesh.wireframe_edges.flatten()
glDrawElements(GL_LINES, edges.shape[0], GL_UNSIGNED_INT, edges)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_COLOR_ARRAY)
