def flush_labels(self):
gl.glClear(gl.GL_DEPTH_BUFFER_BIT)
gl.glPushMatrix()
gl.glTranslatef(-self.game.camera_x * defs.WINDOW_SCALE[0],
-self.game.camera_y * defs.WINDOW_SCALE[1], 0)
for label, x, y, scale in self.labels:
if scale:
gl.glPushMatrix()
label.anchor_x = 'center'
label.anchor_y = 'center'
gl.glTranslatef(x * defs.WINDOW_SCALE[0],
y * defs.WINDOW_SCALE[1], 0)
gl.glScalef(*scale)
label.x = label.y = 0
label.draw()
gl.glPopMatrix()
else:
label.x = x * defs.WINDOW_SCALE[0]
label.y = y * defs.WINDOW_SCALE[1]
label.draw()
self.labels = []
gl.glColor3f(1, 1, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glPopMatrix()
# self.fps_label.draw()
self.game.score.draw()
def on(self):
gl.glPushMatrix()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glPushAttrib(gl.GL_LIGHTING_BIT)
gl.glEnable(gl.GL_LIGHTING)
for l in self:
l.on()
def draw_objects(self):
'''called in the middle of ondraw after the buffer has been cleared'''
self.create_objects()
glPushMatrix()
if self.orthographic:
glTranslatef(0, 0, -3 * self.dist) # Move back
else:
glTranslatef(0, 0, -self.dist) # Move back
# Rotate according to trackball
glMultMatrixd(build_rotmatrix(self.basequat))
# Move origin to bottom left of platform
platformx0 = -self.build_dimensions[3] - self.parent.platform.width / 2
platformy0 = -self.build_dimensions[4] - self.parent.platform.depth / 2
glTranslatef(platformx0, platformy0, 0)
for obj in self.parent.objects:
if not obj.model \
or not obj.model.loaded \
or not obj.model.initialized:
continue
glPushMatrix()
glTranslatef(*(obj.offsets))
glTranslatef(*(obj.centeroffset))
glRotatef(obj.rot, 0.0, 0.0, 1.0)
glScalef(*obj.scale)
obj.model.display()
glPopMatrix()
glPopMatrix()
def draw_ents(self, ents):
for ent in ents:
glPushMatrix()
glTranslatef(ent.body.position.x, ent.body.position.y, 0)
glRotatef(ent.body.angle * 180 / pi, 0, 0, 1)
ent.batch.draw()
glPopMatrix()
def on_draw(self):
pyglet.gl.glClearColor(0.2,0.2,0.8,1)
self.clear()
gl.glPushMatrix()
gl.glTranslatef(self.camera[0], self.camera[1], 0)
pyglet.gl.glColor4f(1,1,1,1)
for territory in self.landmass.land_terrs:
for tri in territory.triangles:
pyglet.gl.glColor4f(*territory.color)
pyglet.graphics.draw(
3, pyglet.gl.GL_TRIANGLES, ('v2f', tri)
)
for line in territory.lines:
pyglet.gl.glColor4f(*line.color)
self.draw_line(line.a.x, line.a.y, line.b.x, line.b.y)
for terr in self.landmass.sea_terrs:
for line in terr.lines:
pyglet.gl.glColor4f(*line.color)
self.draw_line(line.a.x, line.a.y, line.b.x, line.b.y)
if self.draw_capitals:
for terr in itertools.chain(self.landmass.land_terrs, self.landmass.sea_terrs):
pyglet.gl.glColor4f(1,1,1,1)
w = terr.label.content_width/2+2
h = terr.label.content_height/2
self.draw_rect(terr.x-w, terr.y-h, terr.x+w, terr.y+h)
pyglet.gl.glColor4f(1,1,1,1)
self.batch.draw()
gl.glPopMatrix()
def on_draw(self, dt=0):
env.dt = dt
if self.load_countdown == 0:
if self.music_countdown > 0:
self.music_countdown -= dt
if self.music_countdown <= 0:
music.new_song('The_Creature_Sneaks')
if self.mode == GUI:
gl.glLoadIdentity()
if env.scale_factor != 1.0:
gl.glPushMatrix()
env.scale()
gl.glClearColor(1,1,1,1)
self.clear()
gui.draw_card()
if gui.current_card == gui.START: self.start_game()
if gui.current_card == gui.QUIT: pyglet.app.exit()
if gui.current_card == gui.LOAD: self.load_game()
if env.scale_factor != 1.0:
gl.glPopMatrix()
elif self.load_countdown > 1:
self.draw_load_screen()
self.load_countdown -= 1
else:
self.init_resources()
self.init_gui()
self.load_countdown = 0
def display(self, mode_2d=False):
with self.lock:
glPushMatrix()
glTranslatef(self.offset_x, self.offset_y, 0)
glEnableClientState(GL_VERTEX_ARRAY)
has_vbo = isinstance(self.vertex_buffer, VertexBufferObject)
if self.display_travels:
self._display_travels(has_vbo)
glEnable(GL_LIGHTING)
glEnableClientState(GL_NORMAL_ARRAY)
glEnableClientState(GL_COLOR_ARRAY)
glMaterialfv(GL_FRONT, GL_SPECULAR, vec(1, 1, 1, 1))
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0, 0, 0))
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50)
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
self._display_movements(has_vbo)
glDisable(GL_LIGHTING)
glDisableClientState(GL_COLOR_ARRAY)
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_NORMAL_ARRAY)
glPopMatrix()
def _drawLUTtoScreen(self):
"""(private) Used to set the LUT in Bits++ mode.
Should not be needed by user if attached to a ``psychopy.visual.Window()``
since this will automatically draw the LUT as part of the screen refresh.
"""
#push the projection matrix and set to orthorgaphic
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glPushMatrix()
GL.glLoadIdentity()
GL.glOrtho( 0, self.win.size[0],self.win.size[1], 0, 0, 1 ) #this also sets the 0,0 to be top-left
#but return to modelview for rendering
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
#draw the pixels
GL.glActiveTextureARB(GL.GL_TEXTURE0_ARB)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glActiveTextureARB(GL.GL_TEXTURE1_ARB)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glRasterPos2i(0,1)
GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1)
GL.glDrawPixels(len(self._HEADandLUT),1,
GL.GL_RGB,GL.GL_UNSIGNED_BYTE,
self._HEADandLUTstr)
#GL.glDrawPixels(524,1, GL.GL_RGB,GL.GL_UNSIGNED_BYTE, self._HEADandLUTstr)
#return to 3D mode (go and pop the projection matrix)
GL.glMatrixMode( GL.GL_PROJECTION )
GL.glPopMatrix()
GL.glMatrixMode( GL.GL_MODELVIEW )
def draw(self):
if self.graph:
glPushMatrix()
glScalef(self.scale, self.scale, 1.0)
self.graph.draw()
glPopMatrix()
self.grid.batch.draw()
def translate(self,dx,dy,dz):
glPushMatrix()
glLoadIdentity()
glTranslatef(dx,dy,dz)
glMultMatrixf(self.matrix)
self.matrix=get_model_matrix()
glPopMatrix()
def circle(pos, radius, color=(1.0,1.0,1.0), alpha=1.0,segments=6):
"""
Draws a circle with gluDisk
:param pos: center of the circle
:type pos: 2-float tuple
:param radius: radius of the circle
:type radius: float
:param color: the color in [0..1] range
:type color: 3-float tuple
:param alpha: the alpha value in [0..1] range
:param segments: number of segments
:type segments: int
"""
glDisable(GL_TEXTURE_2D)
c = gluNewQuadric()
glColor4f(color[0], color[1], color[2], alpha)
glPushMatrix()
glTranslatef(pos[0], pos[1], 0)
gluDisk(c, 0, radius, segments, 1)
glPopMatrix()
glColor4f(1.0,1.0,1.0,1.0)
glEnable(GL_TEXTURE_2D)
def rotate(self,ang,rx,ry,rz):
glPushMatrix()
glLoadIdentity()
glRotatef(ang,rx,ry,rz)
glMultMatrixf(self.matrix)
self.matrix=get_model_matrix()
glPopMatrix()
def render(self):
gl.glPushMatrix()
gl.glTranslatef(self.x + self.width / 2, self.y + self.height / 2, 0)
gl.glRotatef(self.angle, 0, 0, 1)
gl.glTranslatef(-self.x - self.width / 2, -self.y - self.height / 2, 0)
self.batch.draw()
gl.glPopMatrix()
gl.glPushMatrix()
cx, cy, cw, ch = cannon_rects[0]
gl.glTranslatef(self.x + cx + cw / 2, self.y + cy + ch / 2, 0)
gl.glRotatef(self.cannon_angle - 90, 0, 0, 1)
gl.glTranslatef(-self.x - cx - cw / 2, -self.y - cy, 0)
self.cannon_batch.draw()
gl.glPopMatrix()
self.batch = pyglet.graphics.Batch()
self.cannon_batch = pyglet.graphics.Batch()
def draw(self):
# set up projection
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glViewport(self.x, self.y, self.width, self.height)
gl.glOrtho(0, self.width, 0, self.height, self.near, self.far)
gl.glMatrixMode(gl.GL_MODELVIEW)
fx, fy = self._determine_focus()
w2 = self.width / 2
h2 = self.height / 2
x1, y1 = fx - w2, fy - h2
x2, y2 = fx + w2, fy + h2
gl.glPushMatrix()
gl.glTranslatef(self.width / 2 - fx, self.height / 2 - fy, 0)
for layer in self.layers:
if hasattr(layer, 'x'):
translate = layer.x or layer.y
else:
translate = False
if translate:
gl.glPushMatrix()
gl.glTranslatef(layer.x, layer.y, 0)
layer.draw()
if translate:
gl.glPopMatrix()
gl.glPopMatrix()
def draw_objects(self):
'''called in the middle of ondraw after the buffer has been cleared'''
self.create_objects()
glPushMatrix()
# Rotate according to trackball
glMultMatrixd(build_rotmatrix(self.basequat))
# Move origin to bottom left of platform
platformx0 = -self.build_dimensions[3] - self.parent.platform.width / 2
platformy0 = -self.build_dimensions[4] - self.parent.platform.depth / 2
glTranslatef(platformx0, platformy0, 0)
light_z = max(self.parent.platform.width, self.parent.platform.depth)
glLightfv(GL_LIGHT0, GL_POSITION, vec(0,
self.parent.platform.depth / 2,
light_z, 0))
glLightfv(GL_LIGHT1, GL_POSITION, vec(self.parent.platform.width,
self.parent.platform.depth / 2,
light_z, 0))
for obj in self.parent.objects:
if not obj.model \
or not obj.model.loaded \
or not obj.model.initialized:
continue
glPushMatrix()
glTranslatef(*(obj.offsets))
glTranslatef(*(obj.centeroffset))
glRotatef(obj.rot, 0.0, 0.0, 1.0)
glScalef(*obj.scale)
obj.model.display()
glPopMatrix()
glPopMatrix()
def render(self, geometry):
""" Add the sphere to the view.
:param scene: The view to render the model into
:type scene: pyglet_helper.objects.View
"""
# Renders a simple sphere with the #2 level of detail.
if self.radius == 0.0:
return
self.init_model(geometry)
coverage_levels = [30, 100, 500, 5000]
lod = self.lod_adjust(geometry, coverage_levels, self.pos, self.radius)
gl.glPushMatrix()
self.model_world_transform(geometry.gcf, self.scale).gl_mult()
self.color.gl_set(self.opacity)
if self.translucent:
# Spheres are convex, so we don't need to sort
gl.glEnable(gl.GL_CULL_FACE)
# Render the back half (inside)
gl.glCullFace(gl.GL_FRONT)
geometry.sphere_model[lod].gl_render()
# Render the front half (outside)
gl.glCullFace(gl.GL_BACK)
geometry.sphere_model[lod].gl_render()
else:
# Render a simple sphere.
geometry.sphere_model[lod].gl_render()
gl.glPopMatrix()
def draw(self):
glPushMatrix()
glTranslatef(self.xoffset, self.yoffset, self.zoffset)
def color(i):
if i % self.graduations_major == 0:
glColor4f(*self.color_grads_major)
elif i % (self.graduations_major / 2) == 0:
glColor4f(*self.color_grads_interm)
else:
if self.light: return False
glColor4f(*self.color_grads_minor)
return True
# draw the grid
glBegin(GL_LINES)
for i in range(0, int(math.ceil(self.width + 1))):
if color(i):
glVertex3f(float(i), 0.0, 0.0)
glVertex3f(float(i), self.depth, 0.0)
for i in range(0, int(math.ceil(self.depth + 1))):
if color(i):
glVertex3f(0, float(i), 0.0)
glVertex3f(self.width, float(i), 0.0)
glEnd()
# draw fill
glColor4f(*self.color_fill)
glRectf(0.0, 0.0, float(self.width), float(self.depth))
glPopMatrix()
def render(self, scene):
"""Add the cone to the scene.
:param scene: The view to render the model into
:type scene: pyglet_helper.objects.View
"""
if self.radius == 0:
return
self.init_model(scene)
coverage_levels = [10, 30, 90, 250, 450]
lod = self.lod_adjust(scene, coverage_levels, self.pos, self.radius)
length = self.axis.mag()
gl.glPushMatrix()
self.model_world_transform(scene.gcf, Vector([length, self.radius,
self.radius])).gl_mult()
self.color.gl_set(self.opacity)
if self.translucent:
gl.glEnable(gl.GL_CULL_FACE)
# Render the back half.
gl.glCullFace(gl.GL_FRONT)
scene.cone_model[lod].gl_render()
# Render the front half.
gl.glCullFace(gl.GL_BACK)
scene.cone_model[lod].gl_render()
else:
scene.cone_model[lod].gl_render()
gl.glPopMatrix()
def paint(self, peg):
batch = self.get_batch()
glPushMatrix()
glTranslatef(peg.x, peg.y, 0)
glRotatef(peg.angle, 0, 0, 1)
batch.draw()
glPopMatrix()
def _layerProjectLocalToScreen(self):
"""Maps self.coordLocal to self.coordScreen within OpenGL."""
if self._scissorBox is None and self.localBounds is None:
return
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glPushMatrix()
gl.glLoadIdentity()
# gluOrtho2D declares the render space for the corners of the window.
# So, we want to set it up in such a way that our layer renders in
# the right place. In other words, determine window corners that
# map cl -> cs. All clipping, etc is already handled by the coordsLocal
# getter.
cs = self.coordsScreen
cl = self.coordsLocal
sw = self.scene.width
sh = self.scene.height
# Determine the window width and height. We want a local-sized chunk
# of this to correspond to a screen-sized chunk of the screen. That is,
# cl[2] / ww == cs[2] / sw
ww = cl[2] * sw / cs[2]
wh = cl[3] * sh / cs[3]
# cs[0] / sw = (x - nx) / ww
nx = cl[0] - cs[0] * ww / sw
ny = cl[1] - cs[1] * wh / sh
gl.gluOrtho2D(nx, nx+ww, ny, ny+wh)
gl.glMatrixMode(gl.GL_MODELVIEW)
def set_state(self):
gl.glPushMatrix()
gl.glMultMatrixf(rendering.matrix_to_gl(self.transform))
if self.texture:
gl.glEnable(self.texture.target)
gl.glBindTexture(self.texture.target, self.texture.id)
def draw(self):
if self._dirty:
self._context = Context()
self._parts = []
self.free()
self.render()
self.build_vbo()
self._dirty = False
# set
gl.glEnable(self._texture.target)
gl.glBindTexture(self._texture.target, self._texture.id)
gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glPushMatrix()
self.transform()
# cuadric.begin()
self._vertex_list.draw(gl.GL_TRIANGLES)
# cuadric.end()
# unset
gl.glPopMatrix()
gl.glPopAttrib()
gl.glDisable(self._texture.target)
def draw(self):
if self.batch is not None:
glPushMatrix()
glScalef(self.scale, self.scale, 0)
self.batch.draw()
glPopMatrix()
self.grid.batch.draw()
def draw():
window.clear()
for x in range(0, window.width+space_img.width, space_img.width):
for y in range(0, window.height+space_img.height, space_img.height):
space_img.blit(x=x, y=y)
exhaust_batch.draw()
for y_offset in (-window.height, 0, window.height):
gl.glPushMatrix()
gl.glTranslatef(0, y_offset, 0)
ufo_batch.draw()
gl.glPopMatrix()
for x_offset in (-window.width, 0, window.width):
for y_offset in (-window.height, 0, window.height):
gl.glPushMatrix()
gl.glTranslatef(x_offset, y_offset, 0)
main_batch.draw()
gl.glPopMatrix()
for i in range(ship.lives):
life_sprite.y = 40
life_sprite.x = 30 + 40 * i
life_sprite.draw()
level_label.draw()
def draw(self):
# Update list of entities
# TODO this should actually update instead of recomputing all day, but, whatever
entity_batch = pyglet.graphics.Batch()
for _, entity in self.map_layer.children_names['entities'].children:
x, y = entity.position
w, h = entity.size
x0 = entity.position[0] - entity.image_anchor[0] * entity.scale
y0 = entity.position[1] - entity.image_anchor[1] * entity.scale
x1, y1 = x0 + w, y0 + h
entity_batch.add(4, gl.GL_QUADS, self.outlines_group,
('v2f', (x0, y0, x0, y1, x1, y1, x1, y0)),
('c4f', (1.0, 1.0, 0.0, 0.5) * 4))
# This is a diamond but at scale it looks enough like a dot
D = 3
entity_batch.add(4, gl.GL_QUADS, None,
('v2f', (x + D, y, x, y - D, x - D, y, x, y + D)),
('c4f', (1.0, 1.0, 0.0, 1.0) * 4))
# Collision footprint... kinda
R = entity.entity_type.shape
entity_batch.add(4, gl.GL_QUADS, None,
('v2f', (x - R, y - R, x + R, y - R, x + R, y + R, x - R, y + R)),
('c4f', (1.0, 1.0, 0.0, 0.2) * 4))
# TODO wtf is GL_CURRENT_BIT
gl.glPushMatrix()
self.transform()
self.grid_batch.draw()
entity_batch.draw()
gl.glPopMatrix()
def draw_world_items(self, glyphs):
'''
Draw all passed glyphs
'''
shader = None
for position, orientation, glyph in glyphs:
gl.glPushMatrix()
gl.glTranslatef(*position)
if orientation and orientation != Orientation.Identity:
gl.glMultMatrixf(orientation.matrix)
if glyph.shader is not shader:
shader = glyph.shader
shader.use()
gl_wrap.glBindVertexArray(glyph.vao)
gl.glDrawElements(
gl.GL_TRIANGLES,
len(glyph.glindices),
glyph.index_type,
glyph.glindices
)
gl.glPopMatrix()
gl_wrap.glBindVertexArray(0)
Shader.unuse()
def on_draw(self):
self.window.clear()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glPushMatrix()
gl.glLoadIdentity()
self.camera()
gl.glEnable(self.grass.target)
gl.glEnable(gl.GL_BLEND)
gl.glBindTexture(self.grass.target, self.grass.id)
W = 10000.
graphics.draw(4, gl.GL_QUADS,
('v2f', (-W, -W, W, -W, W, W, -W, W)),
('t2f', (0., 0., W*5., 0., W*5., W*5., 0., W*5.))
)
gl.glDisable(self.grass.target)
for lane in self.lanes:
self.draw_lane_surface(lane)
for lane in self.lanes:
self.draw_lane_lines(lane)
for obj in self.objects:
self.draw_object(obj)
for car in self.cars:
if car!=self.main_car and car not in self.visible_cars:
self.draw_car(self.anim_x[car], car.color)
if self.heat is not None:
self.draw_heatmap()
for car in self.cars:
if car==self.main_car or car in self.visible_cars:
self.draw_car(self.anim_x[car], car.color)
gl.glPopMatrix()
if isinstance(self.main_car, Car):
self.label.text = 'Speed: %.2f'%self.anim_x[self.main_car][3]
self.label.draw()
if self.output is not None:
pyglet.image.get_buffer_manager().get_color_buffer().save(self.output.format(self.frame))
def draw_axes(self):
'draw x y z axis in r g b with text labels'
gl.glPushMatrix()
gl.glScalef( 1.1, 1.1, 1.1)
o = 0, 0, 0
x = 1, 0, 0
y = 0, 1, 0
z = 0, 0, 1
verts = numpy.array([ o, x, o, y, o, z], dtype=constants.DTYPE )
colors = numpy.array([ x, x, y, y, z, z], dtype=constants.DTYPE )
idxs = numpy.cast[constants.INTDTYPE]( numpy.mgrid[:6] )
self.drawlines( verts, colors, idxs)
def draw_axis_label( name, xyz):
'draw a single label'
gl.glPushMatrix()
gl.glTranslatef( xyz[0], xyz[1], xyz[2] )
gl.glScalef( .01, .01, .01 )
gl.glRotatef( 90, 0, 1, 0 )
gl.glRotatef( 90, 0, 0, 1 )
pyglet.text.Label(name).draw()
gl.glPopMatrix()
draw_axis_label( 'x', x)
draw_axis_label( 'y', y)
draw_axis_label( 'z', z)
gl.glPopMatrix()
def drawSpace(self, window):
gl.glPushMatrix()
# GL matrices are applied last-added-first, so this *is* the right
# order for pushing them.
gl.glTranslatef(-self.viewportOrigin[0], -self.viewportOrigin[1], 0.0)
if self.shake is not None:
# We want to rotate around the center of the current viewport
# vpc = view port center
vpc_x = self.viewportOrigin[0] + self.windowProps.windowWidth//2
vpc_y = self.viewportOrigin[1] + self.windowProps.windowHeight//2
gl.glTranslatef(vpc_x, vpc_y, 0.0)
gl.glRotatef(self.shake.getAngle(), 0, 0, 1)
gl.glTranslatef(-vpc_x, -vpc_y, 0.0)
ge = self.gameElements
ge.starField.draw()
ge.swarm.draw()
if not self.explodedMarker.done():
ge.ship.draw()
if self.endGame and not self.drawFrameMarker.done():
self.endGame.draw(window)
for shot in ge.shots:
if shot.alive:
shot.draw()
gl.glPopMatrix()
def draw(self, win=None):
"""Draw the current frame to a particular visual.Window (or to the
default win for this object if not specified). The current
position in the movie will be determined automatically.
This method should be called on every frame that the movie is
meant to appear.
"""
if (self.status == NOT_STARTED or
(self.status == FINISHED and self.loop)):
self.play()
elif self.status == FINISHED and not self.loop:
return
if win is None:
win = self.win
self._selectWindow(win)
self._updateFrameTexture() # will check if it's needed
# scale the drawing frame and get to centre of field
GL.glPushMatrix() # push before drawing, pop after
# push the data for client attributes
GL.glPushClientAttrib(GL.GL_CLIENT_ALL_ATTRIB_BITS)
self.win.setScale('pix')
# move to centre of stimulus and rotate
vertsPix = self.verticesPix
# bind textures
GL.glActiveTexture(GL.GL_TEXTURE1)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._texID)
GL.glEnable(GL.GL_TEXTURE_2D)
# sets opacity (1,1,1 = RGB placeholder)
GL.glColor4f(1, 1, 1, self.opacity)
array = (GL.GLfloat * 32)(
1, 1, # texture coords
vertsPix[0, 0], vertsPix[0, 1], 0., # vertex
0, 1,
vertsPix[1, 0], vertsPix[1, 1], 0.,
0, 0,
vertsPix[2, 0], vertsPix[2, 1], 0.,
1, 0,
vertsPix[3, 0], vertsPix[3, 1], 0.,
)
# 2D texture array, 3D vertex array
GL.glInterleavedArrays(GL.GL_T2F_V3F, 0, array)
GL.glDrawArrays(GL.GL_QUADS, 0, 4)
GL.glPopClientAttrib()
GL.glPopAttrib()
GL.glPopMatrix()
# unbind the textures
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glEnable(GL.GL_TEXTURE_2D) # implicitly disables 1D
def on_draw(self):
"""
Run the actual draw calls.
"""
if self._profile:
profiler = self.Profiler()
profiler.start()
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera = np.linalg.inv(self.scene.camera_transform)
# apply the camera transform to the matrix stack
gl.glMultMatrixf(rendering.matrix_to_gl(transform_camera))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
# how many nodes did we start with
count_original = len(node_names)
count = -1
# if we are rendering an axis marker at the world
if self._axis and not self.view['axis'] == 'without_world':
# we stored it as a vertex list
self._axis.draw(mode=gl.GL_TRIANGLES)
if self._grid:
self._grid.draw(mode=gl.GL_LINES)
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
if current_node in self._nodes_hidden:
continue
# get the transform from world to geometry and mesh name
transform, geometry_name = self.scene.graph.get(current_node)
# if no geometry at this frame continue without rendering
if geometry_name is None:
continue
# if a geometry is marked as fixed apply the inverse view transform
if self.fixed is not None and geometry_name in self.fixed:
# remove altered camera transform from fixed geometry
transform_fix = np.linalg.inv(
np.dot(self._initial_camera_transform, transform_camera))
# apply the transform so the fixed geometry doesn't move
transform = np.dot(transform, transform_fix)
# get a reference to the mesh so we can check transparency
mesh = self.scene.geometry[geometry_name]
if mesh.is_empty:
continue
# get the GL mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# if you draw a coplanar line with a triangle it will z-fight
# the best way to do this is probably a shader but this works fine
if mode == gl.GL_LINES:
# apply the offset in camera space
transform = util.multi_dot([
transform,
np.linalg.inv(transform_camera), self._line_offset,
transform_camera
])
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# draw an axis marker for each mesh frame
if self.view['axis'] == 'all':
self._axis.draw(mode=gl.GL_TRIANGLES)
elif self.view['axis'] == 'without_world':
if count > 0:
self._axis.draw(mode=gl.GL_TRIANGLES)
# transparent things must be drawn last
if (hasattr(mesh, 'visual')
and hasattr(mesh.visual, 'transparency')
and mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
# add the node to be drawn last
node_names.append(current_node)
# pop the matrix stack for now
gl.glPopMatrix()
# come back to this mesh later
continue
# if we have texture enable the target texture
texture = None
if geometry_name in self.textures:
texture = self.textures[geometry_name]
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
# disable texture after using
if texture is not None:
gl.glDisable(texture.target)
if self._profile:
profiler.stop()
print(profiler.output_text(unicode=True, color=True))
def on_draw():
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LINE_SMOOTH)
width, height = window.get_size()
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(60, width / float(height), 0.01, 20)
gl.glMatrixMode(gl.GL_TEXTURE)
gl.glLoadIdentity()
# texcoords are [0..1] and relative to top-left pixel corner, add 0.5 to center
gl.glTranslatef(0.5 / image_data.width, 0.5 / image_data.height, 0)
# texture size may be increased by pyglet to a power of 2
tw, th = image_data.texture.owner.width, image_data.texture.owner.height
gl.glScalef(image_data.width / float(tw), image_data.height / float(th), 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.gluLookAt(0, 0, 0, 0, 0, 1, 0, -1, 0)
gl.glTranslatef(0, 0, state.distance)
gl.glRotated(state.pitch, 1, 0, 0)
gl.glRotated(state.yaw, 0, 1, 0)
if any(state.mouse_btns):
axes(0.1, 4)
gl.glTranslatef(0, 0, -state.distance)
gl.glTranslatef(*state.translation)
gl.glColor3f(0.5, 0.5, 0.5)
gl.glPushMatrix()
gl.glTranslatef(0, 0.5, 0.5)
grid()
gl.glPopMatrix()
psz = max(window.get_size()) / float(max(w, h)) if state.scale else 1
gl.glPointSize(psz)
distance = (0, 0, 1) if state.attenuation else (1, 0, 0)
gl.glPointParameterfv(gl.GL_POINT_DISTANCE_ATTENUATION,
(gl.GLfloat * 3)(*distance))
if state.lighting:
ldir = [0.5, 0.5, 0.5] # world-space lighting
ldir = np.dot(state.rotation, (0, 0, 1)) # MeshLab style lighting
ldir = list(ldir) + [0] # w=0, directional light
gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, (gl.GLfloat * 4)(*ldir))
gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, (gl.GLfloat * 3)(1.0, 1.0,
1.0))
gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, (gl.GLfloat * 3)(0.75, 0.75,
0.75))
gl.glEnable(gl.GL_LIGHT0)
gl.glEnable(gl.GL_NORMALIZE)
gl.glEnable(gl.GL_LIGHTING)
gl.glColor3f(1, 1, 1)
texture = image_data.get_texture()
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
# comment this to get round points with MSAA on
gl.glEnable(gl.GL_POINT_SPRITE)
if not state.scale and not state.attenuation:
gl.glDisable(gl.GL_MULTISAMPLE) # for true 1px points with MSAA on
vertex_list.draw(gl.GL_POINTS)
gl.glDisable(texture.target)
if not state.scale and not state.attenuation:
gl.glEnable(gl.GL_MULTISAMPLE)
gl.glDisable(gl.GL_LIGHTING)
gl.glColor3f(0.25, 0.25, 0.25)
frustum(depth_intrinsics)
axes()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, width, 0, height, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glMatrixMode(gl.GL_TEXTURE)
gl.glLoadIdentity()
gl.glDisable(gl.GL_DEPTH_TEST)
fps_display.draw()
def draw(self):
gl.glPushMatrix()
self.transform()
self.batch.draw()
gl.glPopMatrix()
def enable(self):
glPushMatrix()
if self.flipx: glRotatef(180, 0, 1., 0)
if self.flipy: glRotatef(180, 1., 0, 0)
def mult_rot_matrix(self, rot):
pgl.glPushMatrix()
pgl.glLoadMatrixf(rot)
pgl.glMultMatrixf(self._rot)
self._rot = get_model_matrix()
pgl.glPopMatrix()
def draw(self):
gl.glPushMatrix()
self.transform()
self.title_label.draw()
gl.glPopMatrix()
def hide(self):
if not self.drawable:
raise Exception('Trying to draw non-drawable shape')
glPushMatrix()
self.vlist = pyglet.graphics.vertex_list(0, ('v2f', []))
glPopMatrix()
def draw(self):
gl.glLineWidth(1)
ecsm = game_scene.ecsm
phys_comp_list = ecsm.comps[phys.PhysicsEcsComponent.name()]
grav_comp_list = ecsm.comps[phys.GravityEcsComponent.name()]
coll_comp_list = ecsm.comps[collision.CollisionEcsComponent.name()]
planet_comp_list = ecsm.comps[planet.PlanetEcsComponent.name()]
ship_comp_list = ecsm.comps[ship.ShipEcsComponent.name()]
base_comp_list = ecsm.comps[base.BaseEcsComponent.name()]
entities = ecsm.entities
player_entity_id = ecsm.get_system(
player.PlayerEscSystem.name()).player_entity_id
player_physc = ecsm.get_entity_comp(player_entity_id,
phys.PhysicsEcsComponent.name())
# if player_physc:
# tx = (-player_physc.pos.x * ZOOM) + const.WIDTH // 2
# ty = (-player_physc.pos.y * ZOOM) + const.HEIGHT // 2
# else:
tx = const.WIDTH // 2
ty = const.HEIGHT // 2
gl.glColor3f(0, 0, 0.2)
for i in range(0, const.WIDTH, 50):
gl.glBegin(gl.GL_LINES)
gl.glVertex2f(i, 0.0)
gl.glVertex2f(i, const.HEIGHT)
gl.glEnd()
for i in range(0, const.HEIGHT, 50):
gl.glBegin(gl.GL_LINES)
gl.glVertex2f(0.0, i)
gl.glVertex2f(const.WIDTH, i)
gl.glEnd()
gl.glPushMatrix()
gl.glLoadIdentity()
gl.glTranslatef(tx, ty, 0.0)
# planet orbots
for idx, eid in enumerate(entities):
planetc = planet_comp_list[idx]
physc = phys_comp_list[idx]
if planetc and physc.static:
# rpc = rend_plan_comp_list[idx]
# render.draw_circle(physc.pos.x * ZOOM, physc.pos.y * ZOOM, collc.radius * ZOOM)
distance = physc.pos.length
if distance:
render.draw_circle(0,
0,
distance * ZOOM,
mode=gl.GL_LINES,
color=(.5, .5, .5, 1))
for idx, eid in enumerate(entities):
shipc = ship_comp_list[idx]
basec = base_comp_list[idx]
planetc = planet_comp_list[idx]
physc = phys_comp_list[idx]
collc = coll_comp_list[idx]
if basec and basec.crew_load > 0:
render.draw_circle(physc.pos.x * ZOOM,
physc.pos.y * ZOOM,
TOKEN_SIZE * ZOOM,
color=(1, 1, 0, 1))
# show planet
elif planetc:
# rpc = rend_plan_comp_list[idx]
render.draw_circle(physc.pos.x * ZOOM,
physc.pos.y * ZOOM,
collc.radius * ZOOM,
color=(.8, .8, .8, 1))
# gc = grav_comp_list[idx]
# if gc and gc.gravity_radius:
# render.draw_circle(physc.pos.x * ZOOM, physc.pos.y * ZOOM, gc.gravity_radius * ZOOM, None, gl.GL_LINE_LOOP, color=(.3, .3, .3, 1))
# labels
for idx, eid in enumerate(entities):
planetc = planet_comp_list[idx]
physc = phys_comp_list[idx]
collc = coll_comp_list[idx]
if planetc:
if planetc.pname:
label = pyglet.text.Label(
planetc.pname,
font_name=font.FONT_MONO.name,
font_size=12,
x=physc.pos.x * ZOOM,
y=(physc.pos.y + (collc.radius + 500)) * ZOOM,
# + collc.radius + 5
anchor_x='center',
anchor_y='center',
color=(255, 255, 255, 120))
label.draw()
# show player position
if player_physc:
render.draw_circle(player_physc.pos.x * ZOOM,
player_physc.pos.y * ZOOM,
TOKEN_SIZE * ZOOM,
color=(1, 0, 0, 1))
gl.glPopMatrix()
def pushed_matrix():
gl.glPushMatrix()
try:
yield
finally:
gl.glPopMatrix()
def on_draw(self):
"""
Run the actual draw calls.
"""
self._update_meshes()
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glLoadIdentity()
# pull the new camera transform from the scene
transform_camera = self.scene.graph.get(
frame_to='world',
frame_from=self.scene.camera.name)[0]
# apply the camera transform to the matrix stack
gl.glMultMatrixf(rendering.matrix_to_gl(transform_camera))
# dragging the mouse moves the view
# but doesn't alter the scene
view = view_to_transform(self.view)
# add the view transform to the stack
gl.glMultMatrixf(rendering.matrix_to_gl(view))
# we want to render fully opaque objects first,
# followed by objects which have transparency
node_names = collections.deque(self.scene.graph.nodes_geometry)
# how many nodes did we start with
count_original = len(node_names)
count = -1
# if we are rendering an axis marker at the world
if self._axis:
# we stored it as a vertex list
self._axis.draw(mode=gl.GL_TRIANGLES)
while len(node_names) > 0:
count += 1
current_node = node_names.popleft()
# get the transform from world to geometry and mesh name
transform, geometry_name = self.scene.graph[current_node]
# if no geometry at this frame continue without rendering
if geometry_name is None:
continue
# if a geometry is marked as fixed apply the inverse view transform
if self.fixed is not None and geometry_name in self.fixed:
transform = np.dot(np.linalg.inv(view), transform)
# get a reference to the mesh so we can check transparency
mesh = self.scene.geometry[geometry_name]
if mesh.is_empty:
continue
# add a new matrix to the model stack
gl.glPushMatrix()
# transform by the nodes transform
gl.glMultMatrixf(rendering.matrix_to_gl(transform))
# draw an axis marker for each mesh frame
if self.view['axis'] == 'all':
self._axis.draw(mode=gl.GL_TRIANGLES)
# transparent things must be drawn last
if (hasattr(mesh, 'visual') and
hasattr(mesh.visual, 'transparency')
and mesh.visual.transparency):
# put the current item onto the back of the queue
if count < count_original:
# add the node to be drawn last
node_names.append(current_node)
# pop the matrix stack for now
gl.glPopMatrix()
# come back to this mesh later
continue
# if we have texture enable the target texture
texture = None
if geometry_name in self.textures:
texture = self.textures[geometry_name]
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
# get the mode of the current geometry
mode = self.vertex_list_mode[geometry_name]
# draw the mesh with its transform applied
self.vertex_list[geometry_name].draw(mode=mode)
# pop the matrix stack as we drew what we needed to draw
gl.glPopMatrix()
# disable texture after using
if texture is not None:
gl.glDisable(texture.target)
def enable(self):
gl.glPushMatrix()
# translate to GL loc ppint
gl.glTranslatef(self.translation[0], self.translation[1], 0)
gl.glRotatef(RAD2DEG * self.rotation, 0, 0, 1.0)
gl.glScalef(self.scale[0], self.scale[1], 1)
def enable(self):
gl.glPushMatrix()
gl.glScalef(self.scale[0], self.scale[1], 1)
gl.glTranslatef(self.newpos[0], self.newpos[1], 0)
gl.glRotatef(RAD2DEG * -self.rotation, 0, 0, 1.0)
gl.glTranslatef(-self.centre[0], -self.centre[1], 0)
def pre_draw(self):
gl.glPushMatrix()
gl.glTranslatef(int(self.x), int(self.y), 0)
def blit_to_texture(self, target, level, x, y, z, internalformat=None):
'''Draw this image to to the currently bound texture at `target`.
If `internalformat` is specified, glTexImage is used to initialise
the texture; otherwise, glTexSubImage is used to update a region.
'''
data_format = self.format
data_pitch = abs(self._current_pitch)
# Determine pixel format from format string
matrix = None
format, type = self._get_gl_format_and_type(data_format)
if format is None:
if (len(data_format) in (3, 4)
and gl.gl_info.have_extension('GL_ARB_imaging')):
# Construct a color matrix to convert to GL_RGBA
def component_column(component):
try:
pos = 'RGBA'.index(component)
return [0] * pos + [1] + [0] * (3 - pos)
except ValueError:
return [0, 0, 0, 0]
# pad to avoid index exceptions
lookup_format = data_format + 'XXX'
matrix = (component_column(lookup_format[0]) +
component_column(lookup_format[1]) +
component_column(lookup_format[2]) +
component_column(lookup_format[3]))
format = {3: gl.GL_RGB, 4: gl.GL_RGBA}.get(len(data_format))
type = gl.GL_UNSIGNED_BYTE
gl.glMatrixMode(gl.GL_COLOR)
gl.glPushMatrix()
gl.glLoadMatrixf((gl.GLfloat * 16)(*matrix))
else:
# Need to convert data to a standard form
data_format = {
1: 'L',
2: 'LA',
3: 'RGB',
4: 'RGBA'
}.get(len(data_format))
format, type = self._get_gl_format_and_type(data_format)
# Workaround: don't use GL_UNPACK_ROW_LENGTH
if gl.current_context._workaround_unpack_row_length:
data_pitch = self.width * len(data_format)
# Get data in required format (hopefully will be the same format it's
# already in, unless that's an obscure format, upside-down or the
# driver is old).
data = self._convert(data_format, data_pitch)
if data_pitch & 0x1:
alignment = 1
elif data_pitch & 0x2:
alignment = 2
else:
alignment = 4
row_length = data_pitch / len(data_format)
gl.glPushClientAttrib(gl.GL_CLIENT_PIXEL_STORE_BIT)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, alignment)
gl.glPixelStorei(gl.GL_UNPACK_ROW_LENGTH, row_length)
self._apply_region_unpack()
gl.glTexParameteri(target, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(target, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
gl.glTexParameteri(target, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
if target == gl.GL_TEXTURE_3D:
assert not internalformat
gl.glTexSubImage3D(target, level, x, y, z, self.width, self.height,
1, format, type, data)
elif internalformat:
gl.glTexImage2D(target, level, internalformat, self.width,
self.height, 0, format, type, data)
else:
gl.glTexSubImage2D(target, level, x, y, self.width, self.height,
format, type, data)
gl.glPopClientAttrib()
if matrix:
gl.glPopMatrix()
gl.glMatrixMode(gl.GL_MODELVIEW)
def draw(self, _Stage, _View, _isClear=False):
""" Draw current batch of triangle vertices, acknowledging the scaling
and rotation of the current display (stage settings)
"""
for iWin, win in enumerate(pyglet.app.windows):
win.switch_to()
xScale = _Stage.scalX_umPerPix * _Stage.winXCorrFact * win.scale
yScale = _Stage.scalY_umPerPix * _Stage.winXCorrFact * win.scale
yWin_5 = win.height // 2
xWin_5 = win.width // 2
xWin_25 = win.width // 4
if len(win.caption) == 0:
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glOrtho(-xWin_5, xWin_5, -yWin_5, yWin_5, -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glPushMatrix()
GL.glTranslatef(_Stage.centOffX_pix, _Stage.centOffY_pix, 0)
GL.glScalef(xScale, yScale, 0.0)
GL.glRotatef(_Stage.rot_angle, 0, 0, 1)
if not _isClear:
self.Batch.draw()
self.BatchSpr.draw()
GL.glPopMatrix()
else:
if _Stage.useScrOvl:
# Draw on first (left) screen
#
GL.glViewport(0, 0, win.width // 2, win.height)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glOrtho(-xWin_25 * _Stage.hFlipScr1,
xWin_25 * _Stage.hFlipScr1,
-yWin_5 * _Stage.vFlipScr1,
yWin_5 * _Stage.vFlipScr1, -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glPushMatrix()
x = _Stage.centOffX_pix
y = _Stage.centOffY_pix
GL.glTranslatef(x, y, 0)
GL.glScalef(xScale, yScale, 0.0)
GL.glRotatef(_Stage.rot_angle, 0, 0, 1)
if not _isClear:
self.Batch.draw()
self.BatchSpr.draw()
GL.glPopMatrix()
# Draw on second (right) screen
#
GL.glViewport(win.width // 2, 0, win.width // 2,
win.height)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glOrtho(-xWin_25 * _Stage.hFlipScr2,
xWin_25 * _Stage.hFlipScr2,
-yWin_5 * _Stage.vFlipScr2,
yWin_5 * _Stage.vFlipScr2, -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glPushMatrix()
self.add_rect_data(win.Scr2Vert)
x = _Stage.centOffX_pix + _Stage.offXScr2_pix
y = _Stage.centOffY_pix + _Stage.offYScr2_pix
GL.glTranslatef(x, y, 0)
GL.glScalef(xScale, yScale, 0.0)
GL.glRotatef(_Stage.rot_angle, 0, 0, 1)
if not _isClear:
self.Batch2.draw()
self.Batch2Spr.draw()
GL.glPopMatrix()
else:
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
GL.glOrtho(-xWin_5, xWin_5, -yWin_5, yWin_5, -1, 1)
GL.glMatrixMode(GL.GL_MODELVIEW)
GL.glLoadIdentity()
GL.glPushMatrix()
GL.glTranslatef(_Stage.centOffX_pix, _Stage.centOffY_pix,
0)
GL.glScalef(xScale, yScale, 0.0)
GL.glRotatef(_Stage.rot_angle, 0, 0, 1)
if not _isClear:
self.Batch.draw()
self.BatchSpr.draw()
GL.glPopMatrix()
def on_draw():
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LINE_SMOOTH)
width, height = window.get_size()
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(60, width / float(height), 0.01, 20)
gl.glMatrixMode(gl.GL_TEXTURE)
gl.glLoadIdentity()
# texcoords are [0..1] and relative to top-left pixel corner, add 0.5 to center
gl.glTranslatef(0.5 / image_data.width, 0.5 / image_data.height, 0)
# texture size may be increased by pyglet to a power of 2
tw, th = image_data.texture.owner.width, image_data.texture.owner.height
gl.glScalef(image_data.width / float(tw), image_data.height / float(th), 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.gluLookAt(0, 0, 0, 0, 0, 1, 0, -1, 0)
gl.glTranslatef(0, 0, state.distance)
gl.glRotated(state.pitch, 1, 0, 0)
gl.glRotated(state.yaw, 0, 1, 0)
""" if any(state.mouse_btns):
axes(0.1, 4) """
gl.glTranslatef(0, 0, -state.distance)
gl.glTranslatef(*state.translation)
gl.glColor3f(0.5, 0.5, 0.5)
gl.glPushMatrix()
gl.glTranslatef(0, 0.5, 0.5)
# grid()
gl.glPopMatrix()
psz = 1
gl.glPointSize(psz)
distance = (1, 0, 0)
gl.glPointParameterfv(gl.GL_POINT_DISTANCE_ATTENUATION,
(gl.GLfloat * 3)(*distance))
gl.glColor3f(1, 1, 1)
texture = image_data.get_texture()
gl.glEnable(texture.target)
gl.glBindTexture(texture.target, texture.id)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
# comment this to get round points with MSAA on
gl.glEnable(gl.GL_POINT_SPRITE)
gl.glDisable(gl.GL_MULTISAMPLE) # for true 1px points with MSAA on
vertex_list.draw(gl.GL_POINTS)
gl.glDisable(texture.target)
gl.glEnable(gl.GL_MULTISAMPLE)
gl.glDisable(gl.GL_LIGHTING)
gl.glColor3f(0.25, 0.25, 0.25)
# frustum(depth_intrinsics)
# axes()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, width, 0, height, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glMatrixMode(gl.GL_TEXTURE)
gl.glLoadIdentity()
gl.glDisable(gl.GL_DEPTH_TEST)
def rotate(angle, axis=(0, 0, 1)):
gl.glPushMatrix()
gl.glRotatef(angle * 180 / pi, *axis)
yield
gl.glPopMatrix()
def draw(self):
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, 0)
gl.glRotatef(self.rot, 0, 0, 1)
self.vertex_list.draw(gl.GL_TRIANGLES)
gl.glPopMatrix()
def render_component(self, component):
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glPushMatrix()
gl.glTranslatef(component.layout.x, component.layout.y, 0.0)
component.shape.vertex_list.draw(component.shape.gl_type)
gl.glPopMatrix()
def translate(x, y=0, z=0):
gl.glPushMatrix()
gl.glTranslatef(x, y, z)
yield
gl.glPopMatrix()
def draw(self):
gl.glDisable(gl.GL_TEXTURE_2D)
border = True
offset = False
image = True
color1 = self.border1
color2 = self.border2
if self.displayType == BUTTON:
if not self.showBorder and not self.over:
border = False
if self.is_pressed():
offset = True
color1, color2 = color2, color1
elif self.displayType == CHECKBOX:
if not self.showBorder and not self.over:
border = False
value = self.checked or self.is_pressed()
if self.imageCheckbox:
if value:
border = True
else:
image = False
else:
if value:
offset = True
color1, color2 = color2, color1
elif self.displayType == HYPERLINK:
if self.is_pressed():
offset = True
if not self.enabled:
border = False
offset = False
draw_rectangle(self.x, self.y, self.x + self.width,
self.y - self.height, self.fill)
gl.glPushAttrib(gl.GL_SCISSOR_BIT)
gl.glPushMatrix()
x, y, width, height = self.player.get_scissor_box(
self.x, self.y - self.height, self.width, self.height)
gl.glScissor(x, y, width, height)
gl.glEnable(gl.GL_SCISSOR_TEST)
if offset:
gl.glTranslatef(2, -2, 0)
sprite = self.imageSprite
if self.imageVisible and image and sprite is not None:
if self.pattern:
startX = self.x
startY = self.y
width = sprite.width
height = sprite.height
for y in xrange(int(math.ceil(float(self.height) / height))):
sprite.y = startY - y * height
for x in xrange(int(math.ceil(float(self.width) / width))):
sprite.x = startX + x * width
sprite.render()
else:
self.imageSprite.render()
if self.displayType != HYPERLINK and self.textColor is not None:
self.label.draw()
gl.glPopMatrix()
if self.displayType == HYPERLINK:
if self.over:
color = self.hyperlinkColor
else:
color = self.textColor
if color is not None:
self.label.draw()
gl.glPopAttrib()
gl.glDisable(gl.GL_TEXTURE_2D)
if border:
# top left
draw_rectangle(self.x, self.y, self.x + self.width, self.y - 1,
color1)
draw_rectangle(self.x, self.y, self.x + 1, self.y - self.height,
color1)
# bottom right
draw_rectangle(self.x + self.width, self.y - self.height, self.x,
self.y - self.height + 1, color2)
draw_rectangle(self.x + self.width, self.y - self.height,
self.x + self.width - 1, self.y, color2)
def draw_objects(self):
'''called in the middle of ondraw after the buffer has been cleared'''
self.create_objects()
glPushMatrix()
glTranslatef(0, 0, -self.dist)
glMultMatrixd(build_rotmatrix(
self.basequat)) # Rotate according to trackball
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
vec(0.2, 0.2, 0.2, 1))
glTranslatef(-self.build_dimensions[3] - self.platform.width / 2,
-self.build_dimensions[4] - self.platform.depth / 2,
0) # Move origin to bottom left of platform
# Draw platform
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glDisable(GL_LIGHTING)
self.platform.draw()
glEnable(GL_LIGHTING)
# Draw mouse
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
inter = self.mouse_to_plane(self.mousepos[0],
self.mousepos[1],
plane_normal=(0, 0, 1),
plane_offset=0,
local_transform=False)
if inter is not None:
glPushMatrix()
glTranslatef(inter[0], inter[1], inter[2])
glBegin(GL_TRIANGLES)
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
vec(1, 0, 0, 1))
glNormal3f(0, 0, 1)
glVertex3f(2, 2, 0)
glVertex3f(-2, 2, 0)
glVertex3f(-2, -2, 0)
glVertex3f(2, -2, 0)
glVertex3f(2, 2, 0)
glVertex3f(-2, -2, 0)
glEnd()
glPopMatrix()
# Draw objects
glDisable(GL_CULL_FACE)
glPushMatrix()
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
vec(0.3, 0.7, 0.5, 1))
for i in self.parent.models:
model = self.parent.models[i]
glPushMatrix()
glTranslatef(*(model.offsets))
glRotatef(model.rot, 0.0, 0.0, 1.0)
glTranslatef(*(model.centeroffset))
glScalef(*model.scale)
model.batch.draw()
glPopMatrix()
glPopMatrix()
glEnable(GL_CULL_FACE)
# Draw cutting plane
if self.parent.cutting:
# FIXME: make this a proper Actor
axis = self.parent.cutting_axis
fixed_dist = self.parent.cutting_dist
dist, plane_width, plane_height = self.get_cutting_plane(
axis, fixed_dist)
if dist is not None:
glPushMatrix()
if axis == "x":
glRotatef(90, 0, 1, 0)
glRotatef(90, 0, 0, 1)
glTranslatef(0, 0, dist)
elif axis == "y":
glRotatef(90, 1, 0, 0)
glTranslatef(0, 0, -dist)
elif axis == "z":
glTranslatef(0, 0, dist)
glDisable(GL_CULL_FACE)
glBegin(GL_TRIANGLES)
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
vec(0, 0.9, 0.15, 0.3))
glNormal3f(0, 0, self.parent.cutting_direction)
glVertex3f(plane_width, plane_height, 0)
glVertex3f(0, plane_height, 0)
glVertex3f(0, 0, 0)
glVertex3f(plane_width, 0, 0)
glVertex3f(plane_width, plane_height, 0)
glVertex3f(0, 0, 0)
glEnd()
glEnable(GL_CULL_FACE)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
glEnable(GL_LINE_SMOOTH)
orig_linewidth = (GLfloat)()
glGetFloatv(GL_LINE_WIDTH, orig_linewidth)
glLineWidth(4.0)
glBegin(GL_LINE_LOOP)
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
vec(0, 0.8, 0.15, 1))
glVertex3f(0, 0, 0)
glVertex3f(0, plane_height, 0)
glVertex3f(plane_width, plane_height, 0)
glVertex3f(plane_width, 0, 0)
glEnd()
glLineWidth(orig_linewidth)
glDisable(GL_LINE_SMOOTH)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
glPopMatrix()
glPopMatrix()
def draw(self):
self.plot._render_lock.acquire()
self.camera.apply_transformation()
calc_verts_pos, calc_verts_len = 0, 0
calc_cverts_pos, calc_cverts_len = 0, 0
should_update_caption = (clock() - self.last_caption_update >
self.caption_update_interval)
if len(self.plot._functions.values()) == 0:
self.drawing_first_object = True
try:
dict.iteritems
except AttributeError:
# Python 3
iterfunctions = iter(self.plot._functions.values())
else:
# Python 2
iterfunctions = self.plot._functions.itervalues()
for r in iterfunctions:
if self.drawing_first_object:
self.camera.set_rot_preset(r.default_rot_preset)
self.drawing_first_object = False
pgl.glPushMatrix()
r._draw()
pgl.glPopMatrix()
# might as well do this while we are
# iterating and have the lock rather
# than locking and iterating twice
# per frame:
if should_update_caption:
try:
if r.calculating_verts:
calc_verts_pos += r.calculating_verts_pos
calc_verts_len += r.calculating_verts_len
if r.calculating_cverts:
calc_cverts_pos += r.calculating_cverts_pos
calc_cverts_len += r.calculating_cverts_len
except ValueError:
pass
for r in self.plot._pobjects:
pgl.glPushMatrix()
r._draw()
pgl.glPopMatrix()
if should_update_caption:
self.update_caption(calc_verts_pos, calc_verts_len,
calc_cverts_pos, calc_cverts_len)
self.last_caption_update = clock()
if self.plot._screenshot:
self.plot._screenshot._execute_saving()
self.plot._render_lock.release()
def draw(self):
if self.updateDraw:
self.updateDraw = False
current = self.height - self.borderPad
for item in self.lines:
line = item.get_label()
line.y = current
current -= line.height
self.update_scrollbar()
glDisable(GL_TEXTURE_2D)
glPushMatrix()
glTranslatef(self.x, self.y - self.height, 0)
# border
if self.border:
if self.border3d:
draw_rectangle(0, 0, self.width, self.height,
BORDER_COLOR_3D_1)
draw_rectangle(1, 1, self.width - 1, self.height - 1,
BORDER_COLOR_3D_2)
draw_rectangle(2, 2, self.width - 2, self.height - 2,
BORDER_COLOR_3D_3)
else:
draw_rectangle(0, 0, self.width, self.height, BORDER_COLOR)
# background
pad = self.borderPad
glColor4ub(*(self.backColor + (255, )))
glBegin(GL_QUADS)
glVertex2f(pad, pad)
glVertex2f(self.width - pad, pad)
glVertex2f(self.width - pad, self.height - pad)
glVertex2f(pad, self.height - pad)
glEnd()
glPushAttrib(GL_SCISSOR_BIT)
x, y, width, height = self.player.get_scissor_box(
self.x + self.borderPad, self.y - self.height + self.borderPad,
self.listWidth, self.height - self.borderPad * 2)
glScissor(x, y, width, height)
glEnable(GL_SCISSOR_TEST)
glTranslatef(0, self.yOffset, 0)
for index, item in enumerate(self.lines):
line = item.get_label()
color = None
if self.selected == index:
color = (139, 190, 228)
elif self.over == index:
color = (191, 219, 240)
if color is not None:
draw_rectangle(pad, line.y - line.height,
self.listWidth + self.borderPad, line.y, color)
line.draw()
glPopAttrib()
glPopMatrix()
if self.scrollBar is not None:
self.scrollBar.draw()
def draw(self):
gl.glColor4ub(255, 255, 255, 255)
gl.glPushMatrix()
self.transform()
self.img.blit(0, 0)
gl.glPopMatrix()
def euler_rotate(self, angle, x, y, z):
pgl.glPushMatrix()
pgl.glLoadMatrixf(self._rot)
pgl.glRotatef(angle, x, y, z)
self._rot = get_model_matrix()
pgl.glPopMatrix()
def draw(self):
mid_x, mid_y = self.get_center()
glLineWidth(2)
if self.displayType == ANALOG_CLOCK:
radius = min(self.width, self.height) / 2.0 - 10
radius_end = radius - 10
glPushMatrix()
glTranslatef(mid_x, mid_y, 0)
if self.clockLabels is not None or self.drawLines:
for i in xrange(0, 12):
glPushMatrix()
angle = get_mark_angle(i + 1)
x_value = math.cos(angle)
y_value = math.sin(angle)
if self.drawLines:
glBegin(GL_LINES)
glColor3ub(*self.color)
glVertex2f(x_value * radius_end, y_value * radius_end)
glVertex2f(x_value * (radius - 20),
y_value * (radius - 20))
glEnd()
if self.clockLabels is not None:
x = x_value * radius
y = y_value * radius
glTranslatef(x, y, 0)
self.clockLabels[-i].draw()
glPopMatrix()
# second pointer
second, minute, hour = self.get_time()
if self.displaySeconds:
display_pointer(get_second_minute_angle(second),
self.secondsColor, radius_end)
if self.displayHours:
display_pointer(get_hour_angle(hour + minute / 60.0),
self.hoursColor, radius_end / 1.5)
if self.displayMinutes:
display_pointer(
get_second_minute_angle(minute + second / 60.0),
self.minutesColor, radius_end)
glPopMatrix()
if self.border is not None:
glPushMatrix()
glTranslatef(self.x + 20, self.y - 20, 0.0)
self.border.draw(GL_LINE_LOOP)
glPopMatrix()
elif self.displayType in (DIGITAL_CLOCK, CALENDAR):
text = self.get_text()
if text != self.text:
self.label.text = text
self.text = text
glPushMatrix()
glTranslatef(self.x, self.y, 0)
self.label.draw()
if self.displayType == DIGITAL_CLOCK and self.drawBorder:
glBegin(GL_LINE_LOOP)
glColor3ub(*self.color)
glVertex2f(0, 0)
glVertex2f(self.width, 0)
glVertex2f(self.width, -self.height)
glVertex2f(0, -self.height)
glEnd()
glPopMatrix()
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 draw(self, win=None):
"""Draw the current frame to a particular visual.Window (or to the
default win for this object if not specified). The current
position in the movie will be determined automatically.
This method should be called on every frame that the movie is
meant to appear.
"""
if (self.status == NOT_STARTED
or (self.status == FINISHED and self.loop)):
self.play()
elif self.status == FINISHED and not self.loop:
return
if win is None:
win = self.win
self._selectWindow(win)
self._updateFrameTexture() # will check if it's needed
# scale the drawing frame and get to centre of field
GL.glPushMatrix() # push before drawing, pop after
# push the data for client attributes
GL.glPushClientAttrib(GL.GL_CLIENT_ALL_ATTRIB_BITS)
self.win.setScale('pix')
# move to centre of stimulus and rotate
vertsPix = self.verticesPix
# bind textures
GL.glActiveTexture(GL.GL_TEXTURE1)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_2D, self._texID)
GL.glEnable(GL.GL_TEXTURE_2D)
# sets opacity (1,1,1 = RGB placeholder)
GL.glColor4f(1, 1, 1, self.opacity)
array = (GL.GLfloat * 32)(
1,
1, # texture coords
vertsPix[0, 0],
vertsPix[0, 1],
0., # vertex
0,
1,
vertsPix[1, 0],
vertsPix[1, 1],
0.,
0,
0,
vertsPix[2, 0],
vertsPix[2, 1],
0.,
1,
0,
vertsPix[3, 0],
vertsPix[3, 1],
0.,
)
# 2D texture array, 3D vertex array
GL.glInterleavedArrays(GL.GL_T2F_V3F, 0, array)
GL.glDrawArrays(GL.GL_QUADS, 0, 4)
GL.glPopClientAttrib()
GL.glPopAttrib()
GL.glPopMatrix()
# unbind the textures
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glEnable(GL.GL_TEXTURE_2D) # implicitly disables 1D
def init_rot_matrix(self):
pgl.glPushMatrix()
pgl.glLoadIdentity()
self._rot = get_model_matrix()
pgl.glPopMatrix()
