def rotate(self, ang, rx, ry, rz):
glPushMatrix()
glLoadIdentity()
glRotatef(ang, rx, ry, rz)
glMultMatrixf(self.matrix)
self.matrix = get_model_matrix()
glPopMatrix()
def set_3d(self):
""" Configure OpenGL to draw in 3d.
"""
width, height = self.get_size()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(65.0, width / float(height), 0.1, DIST)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
x, y = self.rotation
gl.glRotatef(x, 0, 1, 0)
gl.glRotatef(-y, math.cos(math.radians(x)), 0,
math.sin(math.radians(x)))
x, y, z = self.position
gl.glTranslatef(-x, -y, -z)
gl.glEnable(gl.GL_LIGHTING)
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT,
GLfloat4(0.05, 0.05, 0.05, 1.0))
gl.glEnable(gl.GL_COLOR_MATERIAL)
gl.glColorMaterial(gl.GL_FRONT, gl.GL_AMBIENT_AND_DIFFUSE)
#gl.glLightfv(gl.GL_LIGHT1,gl.GL_SPOT_DIRECTION, GLfloat3(0,0,-1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, GLfloat4(0.5, 0.5, 0.5, 1.0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, GLfloat4(1.0, 1.0, 1.0, 1.0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION,
GLfloat4(0.35, 1.0, 0.65, 0.0))
#gl.glLightfv(gl.GL_LIGHT0,gl.GL_SPECULAR, GLfloat4(1,1,1,1))
gl.glDisable(gl.GL_LIGHT0)
gl.glEnable(gl.GL_LIGHT1)
def draw(self, state = [0,0,0]):
gl.glEnable (gl.GL_LINE_SMOOTH);
gl.glHint (gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glLoadIdentity()
gl.glLineWidth(1)
gl.glColor3f(.7,.7,.7)
draw_rect((-.5,0), (.5,-.01))
draw_rect((-.01,0),(.01,1))
gl.glTranslatef(0,self.r_roller,0);
gl.glPushMatrix();
gl.glTranslatef(state[0]*self.r_roller, 0, 0)
gl.glColor3f(0,0,0)
gl.glLineWidth(3)
# gl.glPushMatrix()
gl.glRotatef(-R2D*state[0],0,0,1)
draw_mass_center(self.r_roller, (0,0))
# gl.glPopMatrix()
gl.glRotatef(-R2D*state[1], 0, 0, 1)
gl.glTranslatef(0,self.r_roller,0)
gl.glPushMatrix()
gl.glRotatef(R2D*(state[1]+state[0]),0,0,1)
gl.glPushAttrib(gl.GL_ENABLE_BIT);
gl.glColor3f(.7,.2,.2)
gl.glLineStipple(1, 0xF00F) # [1]
gl.glEnable(gl.GL_LINE_STIPPLE)
draw_line((0,0),(0,1))
gl.glPopAttrib()
gl.glPopMatrix()
gl.glTranslatef(-state[1] * self.r_roller,0,0)
gl.glColor3f(0,0,0)
draw_rect( (-self.l_board/2,0), (self.l_board/2,.02))
gl.glColor3f(.5,.5,.5)
draw_rect((-.01,0), (.01,self.h_body))
gl.glPushMatrix()
gl.glTranslatef(0, self.h_body, 0)
gl.glRotatef(R2D*state[2], 0, 0, 1)
gl.glColor3f(0,0,0);
draw_mass_center(.1, (0,0))
gl.glPopMatrix()
if len(state) >= 8:
gl.glPushMatrix()
gl.glTranslatef(0, self.h_body, 0)
gl.glRotatef(R2D*state[3], 0, 0, 1)
gl.glTranslatef(0, -self.h_body+self.r_roller+.05, 0)
gl.glColor3f(0,0,0);
draw_mass_center(.03, (0,0))
gl.glPopMatrix()
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 transform(self):
"""
Apply ModelView transformations.
You will most likely want to wrap calls to this function with
``glPushMatrix()``/``glPopMatrix()``
"""
x, y = director.get_window_size()
if not (self.grid and self.grid.active):
# only apply the camera if the grid is not active
# otherwise, the camera will be applied inside the grid
self.camera.locate()
gl.glTranslatef(self.position[0], self.position[1], 0)
gl.glTranslatef(self.transform_anchor_x, self.transform_anchor_y, 0)
if self.rotation != 0.0:
gl.glRotatef(-self._rotation, 0, 0, 1)
if self.scale != 1.0 or self.scale_x != 1.0 or self.scale_y != 1.0:
gl.glScalef(self._scale * self._scale_x,
self._scale * self._scale_y, 1)
if self.transform_anchor != (0, 0):
gl.glTranslatef(-self.transform_anchor_x, -self.transform_anchor_y,
0)
def render_labels(self):
# Render for errors and labels of pins
if not self.active and not self.hover:
return
if self.problem:
self.er_label.x = self.x - self.cw - self.offset
self.er_label.y = self.y
self.er_label.draw()
if self.hover:
for label, put in zip(self.in_labels, self.put_pos(self.inputs)):
gl.glPushMatrix()
gl.glTranslatef(put['pos'], self.y + self.ch + 15, 0.0)
gl.glRotatef(45.0, 0.0, 0.0, 1.0)
label.draw()
gl.glPopMatrix()
for label, put in zip(self.out_labels, self.put_pos(self.outputs)):
gl.glPushMatrix()
gl.glTranslatef(put['pos'], self.y - self.ch - 20, 0.0)
gl.glRotatef(45.0, 0.0, 0.0, 1.0)
label.draw()
gl.glPopMatrix()
def on_draw ():
window.clear()
gl.glLoadIdentity()
gl.glTranslatef(0, -128, -512)
gl.glRotatef(rotation[1],0,1,0)
vertex_list.draw(gl.GL_LINES)
window.invalid = False
def drawAgent(self, b):
glPushMatrix()
# apply the transformation for the boid
glTranslatef(b.body.location.x / self.scaleFactor,
b.body.location.y / self.scaleFactor, 0.0)
# a = signedAngle()
glRotatef(
math.degrees(math.atan2(b.body.velocity.x, b.body.velocity.y)),
0.0, 0.0, -1.0)
# render the boid's velocity
if False:
self.render_velocity(b)
# render the boid's view
if self.printFustrum:
if b.type == "Taxi":
self.render_view(b)
elif b.type == "Client":
if b.onboard != 1:
self.render_view(b)
# render the boid itself
self.render_agent(b)
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_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 rotate(self,ang,rx,ry,rz):
glPushMatrix()
glLoadIdentity()
glRotatef(ang,rx,ry,rz)
glMultMatrixf(self.matrix)
self.matrix=get_model_matrix()
glPopMatrix()
def on_resize(width, height):
pgl.glBlendFunc(pgl.GL_SRC_ALPHA, pgl.GL_ONE_MINUS_SRC_ALPHA)
pgl.glViewport(0, 0, 400, 400)
#pgl.glEnable(pgl.GL_CULL_FACE)
pgl.glScalef(100, 100, 0.01)
pgl.glTranslatef(2, 2, 2)
pgl.glRotatef(10, 0, 0, 1)
def __enter__(self):
gl.glPushMatrix()
gl.glLoadIdentity()
x, y = self.position
gl.glTranslatef(self.w // 2, self.h // 2, 0)
gl.glRotatef(degrees(self.angle), 0, 0, -1)
gl.glTranslatef(-int(x), -int(y), 0)
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 render(self, draw_bbox):
"""
Renders the object to screen
"""
if not self.visible:
return
from pyglet import gl
# Draw the bounding box
if draw_bbox:
gl.glColor3f(1, 0, 0)
gl.glBegin(gl.GL_LINE_LOOP)
gl.glVertex3f(self.obj_corners.T[0, 0], 0.01,
self.obj_corners.T[1, 0])
gl.glVertex3f(self.obj_corners.T[0, 1], 0.01,
self.obj_corners.T[1, 1])
gl.glVertex3f(self.obj_corners.T[0, 2], 0.01,
self.obj_corners.T[1, 2])
gl.glVertex3f(self.obj_corners.T[0, 3], 0.01,
self.obj_corners.T[1, 3])
gl.glEnd()
gl.glPushMatrix()
gl.glTranslatef(*self.pos)
gl.glScalef(self.scale, self.scale, self.scale)
gl.glRotatef(self.y_rot, 0, 1, 0)
gl.glColor3f(*self.color)
self.mesh.render()
gl.glPopMatrix()
def _setup_3d(self):
w, h = self.get_size()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LEQUAL)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
viewport = self.get_viewport_size()
gl.glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1]))
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(*self.perspective)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
y, x = self.rotation
gl.glRotatef(x, 0, 1, 0)
gl.glRotatef(-y, math.cos(math.radians(x)), 0,
math.sin(math.radians(x)))
# NOTE: for GL render, its x-z plane is the ground plane,
# so we unpack the position using `(x, z, y)` instead of `(x, y, z)`
x, z, y = self.position
if not self.debug_mode:
y += self.perspective_over_drone[0]
z += self.perspective_over_drone[1]
gl.glTranslatef(-x, -y, -z)
def on_draw(*args):
global time, particles
t = time / FRAMES
window.clear()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(90, 1, 0.1, 100)
gl.glTranslatef(0, 0, -10)
gl.glRotatef(t * 360, 0, 1, 0)
# gl.glRotatef(t * 360, 1, 0, 0)
batch = pyglet.graphics.Batch()
if time == FRAMES:
exit()
points = []
for i in range(K):
points.append(gen_point((i + t) / K, i))
# print(points)
points_to_lines(points, batch)
batch.draw()
save_frame(time % FRAMES)
time += 1
def render(self):
"""
Draws Line
"""
p1 = self.a2
p2 = self.b2
gl.glColor4f(*self.color)
color = (gl.GLfloat * 4)(*self.color)
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, -self.z) # translate to GL loc ppint
gl.glRotatef(self.rotation, 0, 0, 0.1)
if self.style:
gl.glEnable(gl.GL_LINE_STIPPLE)
gl.glLineStipple(1, self.style)
## else :
## glDisable(GL_LINE_STIPPLE)
if self.stroke <= 0:
self.stroke = 1
gl.glLineWidth(self.stroke)
gl.glBegin(gl.GL_LINES)
gl.glVertex2i(int(p1[0]), int(p1[1])) # draw pixel points
gl.glVertex2i(int(p2[0]), int(p2[1]))
gl.glEnd()
if self.style:
gl.glDisable(gl.GL_LINE_STIPPLE)
gl.glPopMatrix()
def render(self, draw_bbox, annotated=False):
"""
Renders the object to screen
"""
if not self.visible:
return
from pyglet import gl
# Draw the bounding box
if draw_bbox:
gl.glColor3f(1, 0, 0)
gl.glBegin(gl.GL_LINE_LOOP)
gl.glVertex3f(self.obj_corners.T[0, 0], 0.01,
self.obj_corners.T[1, 0])
gl.glVertex3f(self.obj_corners.T[0, 1], 0.01,
self.obj_corners.T[1, 1])
gl.glVertex3f(self.obj_corners.T[0, 2], 0.01,
self.obj_corners.T[1, 2])
gl.glVertex3f(self.obj_corners.T[0, 3], 0.01,
self.obj_corners.T[1, 3])
gl.glEnd()
gl.glPushMatrix()
gl.glTranslatef(*self.pos)
gl.glScalef(self.scale, self.scale, self.scale)
gl.glRotatef(self.y_rot, 0, 1, 0)
gl.glColor3f(*self.color)
annotated = annotated and self.on_driveable_tile
if annotated and self.annotated_mesh is not None:
self.annotated_mesh.render(annotated=annotated)
else:
self.mesh.render(annotated=annotated)
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 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)
for obj in self.parent.objects:
if not obj.model \
or not obj.model.loaded:
continue
# Skip (comment out) initialized check, which safely causes empty
# model during progressive load. This can cause exceptions/garbage
# render, but seems fine for now
# May need to lock init() and draw_objects() together
# if not obj.model.initialized:
# continue
glPushMatrix()
glTranslatef(*(obj.offsets))
glRotatef(obj.rot, 0.0, 0.0, 1.0)
glTranslatef(*(obj.centeroffset))
glScalef(*obj.scale)
obj.model.display()
glPopMatrix()
glPopMatrix()
def nakresli_tank(x, y, rotace, barva):
"""Nakresli tank na dane pozici, s rotaci a v dane barve."""
# Zacentruj kresleni na stred tela tanku.
gl.glTranslatef(x, y, 0.0)
# Aplikuj aktualni rotaci.
gl.glRotatef(rotace, 0.0, 0.0, 1.0)
# Nakresli telo tanku ve zvolene barve.
gl.glColor3f(*barva)
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glVertex2f(-TANK_SIRKA / 2, -TANK_DELKA / 2)
gl.glVertex2f(-TANK_SIRKA / 2, +TANK_DELKA / 2)
gl.glVertex2f(+TANK_SIRKA / 2, +TANK_DELKA / 2)
gl.glVertex2f(+TANK_SIRKA / 2, -TANK_DELKA / 2)
gl.glEnd()
# Nakresli hlaven tanku ve standardni barve.
gl.glColor3f(*BARVA_HLAVNE)
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glVertex2f(-HLAVEN_SIRKA / 2, -HLAVEN_DELKA / 2 + HLAVEN_POSUN)
gl.glVertex2f(-HLAVEN_SIRKA / 2, +HLAVEN_DELKA / 2 + HLAVEN_POSUN)
gl.glVertex2f(+HLAVEN_SIRKA / 2, +HLAVEN_DELKA / 2 + HLAVEN_POSUN)
gl.glVertex2f(+HLAVEN_SIRKA / 2, -HLAVEN_DELKA / 2 + HLAVEN_POSUN)
gl.glEnd()
# Vrat rotaci a centrovani do puvodniho stavu.
gl.glRotatef(-rotace, 0.0, 0.0, 1.0)
gl.glTranslatef(-x, -y, 0.0)
def draw(self):
"""Render the view object"""
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, 0)
gl.glRotatef(self.angle, *self.axis)
self.draw_aligned()
gl.glPopMatrix()
def draw(self):
"""Render the particle."""
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, self.z)
gl.glRotatef(self.angle, *self.axis)
self.draw_aligned()
gl.glPopMatrix()
def set_3d(self):
""" Configure OpenGL to draw in 3d.
"""
width, height = self.get_size()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(65.0, width / float(height), 0.1, DIST)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
x, y = self.rotation
gl.glRotatef(x, 0, 1, 0)
gl.glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x)))
x, y, z = self.position
gl.glTranslatef(-x, -y, -z)
gl.glEnable(gl.GL_LIGHTING)
gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, GLfloat4(0.05,0.05,0.05,1.0))
gl.glEnable(gl.GL_COLOR_MATERIAL)
gl.glColorMaterial(gl.GL_FRONT, gl.GL_AMBIENT_AND_DIFFUSE)
#gl.glLightfv(gl.GL_LIGHT1,gl.GL_SPOT_DIRECTION, GLfloat3(0,0,-1))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, GLfloat4(0.5,0.5,0.5,1.0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, GLfloat4(1.0,1.0,1.0,1.0))
gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, GLfloat4(0.35,1.0,0.65,0.0))
#gl.glLightfv(gl.GL_LIGHT0,gl.GL_SPECULAR, GLfloat4(1,1,1,1))
gl.glDisable(gl.GL_LIGHT0)
gl.glEnable(gl.GL_LIGHT1)
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)
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))
glRotatef(obj.rot, 0.0, 0.0, 1.0)
glTranslatef(*(obj.centeroffset))
glScalef(*obj.scale)
obj.model.display()
glPopMatrix()
glPopMatrix()
def render(self):
""" Draw Circle
x, y, z, width in pixel, rotation, color and line width in px
style choices are : GLU_LINE, GLU_FILL, GLU_SILHOUETTE, GLU_POINT
TO DO : textured circles
"""
gl.glColor4f(*self.color)
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, -self.z)
gl.glRotatef(*self.rotation) #angle, bool per axis (x,y,z)
if self.radius < 1: self.radius = 1
if self.stroke:
inner = self.radius - self.stroke # outline width
if inner < 0: inner = 0
else:
inner = 0 # filled
gl.gluQuadricDrawStyle(self.q, self.style)
gl.gluDisk(self.q, inner, self.radius, self.circleresolution,
1) # gluDisk(quad, inner, outer, slices, loops)
gl.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):
self.loadStartPosition()
gl.glRotatef(90.0, 0.0, 0.0, 1.0)
gl.glBegin(gl.GL_QUADS)
gl.glColor3f(1.0, 1.0, 0.0)
tenth = math.pi * 2.0 / 10.0
for z in [-0.1, 0.1]:
for i in xrange(5):
a = float(i) * tenth * 2.0
gl.glVertex3f(0.0, 0.0, z)
gl.glVertex3f(0.4 * math.cos(a - tenth), 0.4 * math.sin(a - tenth), z)
gl.glVertex3f(math.cos(a), math.sin(a), z)
gl.glVertex3f(0.4 * math.cos(a + tenth), 0.4 * math.sin(a + tenth), z)
for i in xrange(5):
a = float(i) * tenth * 2.0
gl.glVertex3f(0.4 * math.cos(a - tenth), 0.4 * math.sin(a - tenth), 0.1)
gl.glVertex3f(math.cos(a), math.sin(a), 0.1)
gl.glVertex3f(math.cos(a), math.sin(a), -0.1)
gl.glVertex3f(0.4 * math.cos(a - tenth), 0.4 * math.sin(a - tenth), -0.1)
gl.glVertex3f(0.4 * math.cos(a + tenth), 0.4 * math.sin(a + tenth), 0.1)
gl.glVertex3f(math.cos(a), math.sin(a), 0.1)
gl.glVertex3f(math.cos(a), math.sin(a), -0.1)
gl.glVertex3f(0.4 * math.cos(a + tenth), 0.4 * math.sin(a + tenth), -0.1)
gl.glEnd()
self.loadStartPosition()
gl.glTranslatef(0.0, 0.0, 0.1)
gl.glScalef(0.01, 0.01, 0.0)
self.label.draw()
gl.glLoadIdentity()
def draw_ellipse_filled(center_x: float, center_y: float,
width: float, height: float, color: Color,
tilt_angle: float = 0):
num_segments = 128
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST)
gl.glLoadIdentity()
gl.glTranslatef(center_x, center_y, 0)
gl.glRotatef(tilt_angle, 0, 0, 1)
# Set color
if len(color) == 4:
gl.glColor4ub(color[0], color[1], color[2], color[3])
elif len(color) == 3:
gl.glColor4ub(color[0], color[1], color[2], 255)
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glVertex3f(0, 0, 0.5)
for segment in range(num_segments + 1):
theta = 2.0 * 3.1415926 * segment / num_segments
x = width * math.cos(theta)
y = height * math.sin(theta)
gl.glVertex3f(x, y, 0.5)
gl.glEnd()
gl.glLoadIdentity()
def display(self, width, height):
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(60., width / float(height), .1, 1000.)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glTranslatef(self.trans[0], self.trans[1], self.trans[2])
gl.glRotatef(self.rot[0], 1.0, 0.0, 0.0)
gl.glRotatef(self.rot[1], 0.0, 1.0, 0.0)
gl.glRotatef(self.rz, 0, 0, 1)
gl.glRotatef(self.ry, 0, 1, 0)
gl.glRotatef(self.rx, 1, 0, 0)
gl.glEnable(gl.GL_LIGHTING)
gl.glColor3f(1, 0, 0)
self.torus.draw()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.glOrtho(0, width, 0, height, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
gl.glDisable(gl.GL_LIGHTING)
gl.glColor3f(0, 1, 0)
self.lowerlabel.text = 'Rx %.2f Ry %.2f Rz %.2f' % (self.rx, self.ry,
self.rz)
self.lowerlabel.draw()
self.upperlabel.text = time.strftime('Now is %H:%M:%S')
self.upperlabel.x = width - self.upperlabel.content_width - 5
self.upperlabel.y = height - self.upperlabel.content_height
self.upperlabel.draw()
def on_draw(*args):
global time, particles
t = time / FRAMES
window.clear()
gl.glMatrixMode(gl.GL_PROJECTION)
gl.glLoadIdentity()
gl.gluPerspective(90, 1, 0.1, 100)
gl.glTranslatef(0, 0, -10)
gl.glRotatef(t * 360, 0, 1, 0)
batch = pyglet.graphics.Batch()
if time == FRAMES:
exit()
points = np.empty((K, 3))
for i in range(K):
points[i] = gen_point((i + t) / K, i, t)
# points = points.reshape(-1)
# batch.add(len(points) // 3, pyglet.graphics.GL_POINTS, None, ("v3f", points))
# print(points)
points_to_lines(points, batch, 1.2)
batch.draw()
save_frame(time % FRAMES)
time += 1
def draw_text(text: str,
start_x: float, start_y: float,
color: Color,
font_size: float = 12,
width: int = 2000,
align="left",
font_name=('Calibri', 'Arial'),
bold: bool = False,
italic: bool = False,
anchor_x="left",
anchor_y="baseline",
rotation=0
):
if len(color) == 3:
color = (color[0], color[1], color[2], 255)
label = pyglet.text.Label(text,
font_name=font_name,
font_size=font_size,
x=0, y=0,
color=color,
multiline=True,
width=width,
align=align,
anchor_x=anchor_x,
anchor_y=anchor_y,
bold=bold,
italic=italic)
gl.glLoadIdentity()
gl.glTranslatef(start_x, start_y, 0)
gl.glRotatef(rotation, 0, 0, 1)
label.draw()
def render_cylinder(self,
base_radius,
height,
slices,
stacks,
top_radius=None):
""" Generate the polygons for a cylinder
:param base_radius: The radius of the bottom of the cylinder.
:type base_radius: float
:param height: The cylinder's height
:type height: float
:param slices: The number of longitudinal lines
:type slices: int
:param stacks: The number of latitudinal lines
:type stacks: int
:param top_radius: The radius of the top of the cylinder. If undefined,
the top radius will be the same as the base radius
:type top_radius: float
"""
# rotate the cylinder so that it is drawn along the VPython axis
# convention
gl.glRotatef(90, 0, 1, 0)
if top_radius is None:
gl.glu.gluCylinder(self.quadric, base_radius, base_radius, height,
slices, stacks)
else:
gl.glu.gluCylinder(self.quadric, base_radius, top_radius, height,
slices, stacks)
gl.glRotatef(-90, 0, 1, 0)
def update(self):
self.ry += self.ryv
gl.glPushMatrix()
gl.glTranslatef(self.x, self.y, self.z)
gl.glRotatef(self.ry, 0, 1, 0)
self.vertex_list.draw(gl.GL_LINES)
gl.glPopMatrix()
def paint(self, peg):
glPushMatrix()
glTranslatef(peg.x, peg.y, 0)
glRotatef(peg.angle, 0, 0, 1)
batch = self.get_batch()
batch.draw()
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_cylinder(self, base_radius, height, slices, stacks,
top_radius=None):
""" Generate the polygons for a cylinder
:param base_radius: The radius of the bottom of the cylinder.
:type base_radius: float
:param height: The cylinder's height
:type height: float
:param slices: The number of longitudinal lines
:type slices: int
:param stacks: The number of latitudinal lines
:type stacks: int
:param top_radius: The radius of the top of the cylinder. If undefined,
the top radius will be the same as the base radius
:type top_radius: float
"""
# rotate the cylinder so that it is drawn along the VPython axis
# convention
gl.glRotatef(90, 0, 1, 0)
if top_radius is None:
gl.glu.gluCylinder(self.quadric, base_radius, base_radius,
height, slices, stacks)
else:
gl.glu.gluCylinder(self.quadric, base_radius, top_radius,
height, slices, stacks)
gl.glRotatef(-90, 0, 1, 0)
def transform(self):
"""
Apply ModelView transformations.
You will most likely want to wrap calls to this function with
``glPushMatrix()``/``glPopMatrix()``
"""
x, y = director.get_window_size()
if not(self.grid and self.grid.active):
# only apply the camera if the grid is not active
# otherwise, the camera will be applied inside the grid
self.camera.locate()
gl.glTranslatef(self.position[0], self.position[1], 0)
gl.glTranslatef(self.transform_anchor_x, self.transform_anchor_y, 0)
if self.rotation != 0.0:
gl.glRotatef(-self._rotation, 0, 0, 1)
if self.scale != 1.0 or self.scale_x != 1.0 or self.scale_y != 1.0:
gl.glScalef(self._scale * self._scale_x, self._scale * self._scale_y, 1)
if self.transform_anchor != (0, 0):
gl.glTranslatef(
-self.transform_anchor_x,
-self.transform_anchor_y,
0)
def rotate(p, state, kwargs):
x, y = p.x, p.y
xp = x + (p.width / 2)
yp = y + (p.height / 2)
gl.glTranslatef(xp, yp, 0)
gl.glRotatef(kwargs['angle'], 0.0, 0.0, 1.0)
gl.glTranslatef(-xp, -yp, 0)
def draw(self):
glPushMatrix()
glRotatef(self.angle, 0., 0., 1.)
glScalef(self.scale, 1., 1.)
glTranslatef(0., -common_res.ray.height/2, 0.)
glColor4f(1., 1., 1., self.alpha)
common_res.ray.blit(0, 0)
glPopMatrix()
def draw(self, scale=1):
gl.glPushMatrix()
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glTranslatef(*self.position)
gl.glRotatef(self.angle, 0, 0, 1)
gl.glScalef(scale, scale, scale)
self.batch.draw()
gl.glPopMatrix()
def _draw_local(self):
super(ShipPartConfigurationView, self)._draw_local()
glPushMatrix()
glRotatef(-self.yaw, 0, 1, 0)
glRotatef(-90, 1, 0, 0)
glScalef(0.025, 0.025, 0.025)
self.infobox.draw()
glPopMatrix()
def on_draw():
window.clear()
gl.glLoadIdentity()
gl.gluLookAt(0, 8, 8, 0, 0, 0, 0, 1, 0)
gl.glRotatef(rot, 1, 0, 0)
gl.glRotatef(rot/2, 0, 1, 0)
batch.draw()
gl.glFinish()
def rotate(f,
angle,
x=0.0, y=0.0, z=1.0):
push()
gl.glRotatef(angle * 180 / pi,
x, y, z)
f()
pop()
def draw_at(self, x, y):
draw.set_color(1,1,1,1)
for unit in self.units:
ix, iy = x-unit.offset[1], y+unit.offset[0]
gl.glPushMatrix()
gl.glTranslatef(ix,iy,0)
gl.glRotatef(unit.local_angle-90,0,0,-1)
unit.image.blit(0,0)
gl.glPopMatrix()
def draw(self):
ray = L('c-ray')
glPushMatrix()
glRotatef(self.angle, 0., 0., 1.)
glScalef(self.scale, 1., 1.)
glTranslatef(0., -ray.height/2, 0.)
glColor4f(1., 1., 1., self.alpha)
ray.blit(0, 0)
glPopMatrix()
def draw(self, win=None):
#set the window to draw to
if win==None: win=self.win
if win.winType=='pyglet': win.winHandle.switch_to()
#work out next default depth
if self.depth==0:
thisDepth = self.win._defDepth
self.win._defDepth += _depthIncrements[self.win.winType]
else:
thisDepth=self.depth
GL.glPushMatrix()
#scale and rotate
prevScale = self.win.setScale(self._winScale)
GL.glTranslatef(self._posRendered[0],self._posRendered[1],thisDepth)#NB depth is set already
GL.glRotatef(self.ori,0.0,0.0,1.0)
self.win.setScale('pix',None, prevScale)
if self._useShaders: #then rgb needs to be set as glColor
#setup color
desiredRGB = (self.rgb*self.contrast+1)/2.0#RGB in range 0:1 and scaled for contrast
if numpy.any(desiredRGB**2.0>1.0):
desiredRGB=[0.6,0.6,0.4]
GL.glColor4f(desiredRGB[0],desiredRGB[1],desiredRGB[2], self.opacity)
else: #color is set in texture, so set glColor to white
GL.glColor4f(1,1,1,1)
GL.glDisable(GL.GL_DEPTH_TEST) #should text have a depth or just on top?
#update list if necss and then call it
if self.win.winType=='pyglet':
#and align based on x anchor
if self.alignHoriz=='right':
GL.glTranslatef(-self.width,0,0)#NB depth is set already
if self.alignHoriz in ['center', 'centre']:
GL.glTranslatef(-self.width/2,0,0)#NB depth is set already
#unbind the mask texture regardless
GL.glActiveTexture(GL.GL_TEXTURE1)
GL.glEnable(GL.GL_TEXTURE_2D)
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
#unbind the main texture
GL.glActiveTexture(GL.GL_TEXTURE0)
GL.glEnable(GL.GL_TEXTURE_2D)
#then allow pyglet to bind and use texture during drawing
self.glyphStr.draw()
GL.glDisable(GL.GL_TEXTURE_2D)
else:
#for pygame we should (and can) use a drawing list
if self.needUpdate: self._updateList()
GL.glCallList(self._listID)
GL.glEnable(GL.GL_DEPTH_TEST) # Enables Depth Testing
GL.glPopMatrix()
def zoomAndRotate(self): """Performs zooming and rotation. Suggested to use with pan during displazing the scene: 1.cam.zoomAndRotate() 2.cam.pan() 3.draw(some 3D objects) """ glTranslatef(0, 0, -self.radius) glRotatef(self.psi - 90, 1, 0, 0) glRotatef(self.fi, 0, 0, 1)
def draw_rectangle_outline(center_x, center_y, width, height, color,
border_width=1, tilt_angle=0):
"""
Draw a rectangle outline.
Args:
:x: x coordinate of top left rectangle point.
:y: y coordinate of top left rectangle point.
:width: width of the rectangle.
:height: height of the rectangle.
:color: color, specified in a list of 3 or 4 bytes in RGB or
RGBA format.
:border_width: width of the lines, in pixels.
:angle: rotation of the rectangle. Defaults to zero.
Returns:
None
Raises:
None
Example:
>>> import arcade
>>> arcade.open_window("Drawing Example", 800, 600)
>>> arcade.set_background_color(arcade.color.WHITE)
>>> arcade.start_render()
>>> arcade.draw_rectangle_outline(278, 150, 45, 105, \
arcade.color.BRITISH_RACING_GREEN, 2)
>>> arcade.finish_render()
>>> arcade.quick_run(0.25)
"""
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
GL.glEnable(GL.GL_LINE_SMOOTH)
GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)
GL.glLoadIdentity()
GL.glTranslatef(center_x, center_y, 0)
if tilt_angle:
GL.glRotatef(tilt_angle, 0, 0, 1)
# Set line width
GL.glLineWidth(border_width)
# Set color
if len(color) == 4:
GL.glColor4ub(color[0], color[1], color[2], color[3])
elif len(color) == 3:
GL.glColor4ub(color[0], color[1], color[2], 255)
GL.glBegin(GL.GL_LINE_LOOP)
GL.glVertex3f(-width // 2, -height // 2, 0.5)
GL.glVertex3f(width // 2, -height // 2, 0.5)
GL.glVertex3f(width // 2, height // 2, 0.5)
GL.glVertex3f(-width // 2, height // 2, 0.5)
GL.glEnd()
def paint(self):
if self.batch is None:
self.get_batch()
glPushMatrix()
glTranslatef(self.peg.x, self.peg.y, self.peg.z)
glRotatef(self.peg.angle, 0, 0, 1)
self.batch.draw()
glPopMatrix()
print'.',
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()
def paint(self):
if self.drawable:
glPushMatrix()
glTranslatef(self.posx, self.posy, 0)
glRotatef(self.angle, 0, 0, 1)
batch = self.get_batch()
batch.draw()
glPopMatrix()
else:
print 'cell', self, 'is not drawable'
def paint(self):
for sh in self.get_instances(self):
if sh.batch is None:
sh.get_batch()
glPushMatrix()
glTranslatef(sh.peg.x, sh.peg.y, sh.peg.z)
glRotatef(sh.peg.angle, 0, 0, 1)
sh.batch.draw()
glPopMatrix()
print'.',
def paint(self):
print ':: displaying C-Shape :', self
batch = self.get_batch()
glPushMatrix()
glTranslatef(self.peg.x, self.peg.y, 0)
glRotatef(self.peg.angle, 0, 0, 1)
batch.draw()
# OPTIMISATION : cs.batch.draw() directement avec batch déjà à jour TODO
glPopMatrix()
print ''
def gl_output(self):
for sh in self.yeld_simple_shapes(self):
if sh.batch is None:
sh.get_batch()
glPushMatrix()
glTranslatef(sh.peg.x, sh.peg.y, 0)
glRotatef(sh.peg.angle, 0, 0, 1)
sh.batch.draw()
print ('.'),
glPopMatrix()
def on_draw(self):
rendr_components, trans_components = self.entity_manager.get_all_components_of_types([Render, Transform])
for render, trans in zip(rendr_components, trans_components):
gl.glPushMatrix()
gl.glTranslatef(trans.x, trans.y, 0.0)
gl.glRotatef(trans.rotation, 0, 0, 1)
gl.glScalef(trans.scale, trans.scale, 1.0)
render.image.blit(trans.anchor_x, trans.anchor_y)
gl.glPopMatrix()
def paint(self):
if self.batch is None:
self.get_batch()
glPushMatrix()
glTranslatef(self.peg.x, self.peg.y, self.peg.z)
glRotatef(self.peg.angle, 0, 0, 1)
self.batch.draw()
# OPTIMISATION : cs.batch.draw() directement avec batch déjà à jour TODO
glPopMatrix()
print '+',
def draw(self):
#print self.body.postion
s = self.size # just a shorthand
gl.glColor4f(*(self.colour + (self.opacity,)))
with shiftView(Vec2d(self.body.position)):
gl.glRotatef(degrees(self.body.angle), 0.1,0.2,1.0)
gl.glBegin(gl.GL_POLYGON)
for vertex in self.verticies:
gl.glVertex2f(*vertex)
gl.glEnd()
