def draw(self):
""" Render the Icosahedron in OGL , This function assumes that a graphics context already exists """
# [1]. If OGL transforms enabled , Translate and rotate the OGL state machine to desired rendering frame
self.state_transform()
# [2]. Set color , size , and shape-specific parameters
glColor3ub(
*self.colors[0]) # Get the color according to the voxel type
# [3]. Render!
pyglet.graphics.draw_indexed(
12, # --------------------- Number of seqential triplet in vertex list
GL_TRIANGLES, # -------------- Draw quadrilaterals
self.
faceDices, # ---------- Indices where the coordinates are stored
(
'v3f', self.vertX
) # vertex list , OpenGL offers an optimized vertex list object , but this is not it
) # 'v3i' # This is for integers I suppose!
# [2]. Set color , size , and shape-specific parameters
glColor3ub(
*self.colors[1]) # Get the color according to the voxel type
pyglet.gl.glLineWidth(3)
# [3]. Render!
pyglet.graphics.draw_indexed(
12, # --------------------- Number of seqential triplet in vertex list
GL_LINES, # -------------- Draw quadrilaterals
self.
linDices, # ---------- Indices where the coordinates are stored
(
'v3f', self.vertX
) # vertex list , OpenGL offers an optimized vertex list object , but this is not it
) # 'v3i' # This is for integers I suppose!
# [4]. If OGL transforms enabled , Return the OGL state machine to previous rendering frame
self.state_untransform()
def draw(self):
""" Draw the axes """
# [1]. If OGL transforms enabled , Translate and rotate the OGL state machine to desired rendering frame
self.state_transform()
# [2]. Set color , size , and shape-specific parameters
pyglet.gl.glLineWidth(self.__class__.lineWidth)
# [3]. Render! # Basis vectors are drawn one at a time in the conventional colors
glColor3ub(*self.colors[0]) # There is only one color
# Draw the vector shaft
pyglet.graphics.draw_indexed(
6, # ------------------ Number of seqential triplet in vertex list
GL_LINES, # ------------ Draw quadrilaterals
self.ndx_vctr, # ----- Indices where the coordinates are stored
(
'v3f', self.vertX
) #- Vertex list , OpenGL offers an optimized vertex list object , but this is not it
)
# Draw the fletchings
for i in xrange(len(self.fltchngs)):
pyglet.graphics.draw_indexed(
6, # ------------------ Number of seqential triplet in vertex list
GL_TRIANGLES, # -------- Draw quadrilaterals
self.
fltchngs[i], # ------ Indices where the coordinates are stored
(
'v3f', self.vertX
) #- Vertex list , OpenGL offers an optimized vertex list object , but this is not it
)
# [4]. If OGL transforms enabled , Return the OGL state machine to previous rendering frame
self.state_untransform()
def draw(self):
""" Render the point """
# [1]. If OGL transforms enabled , Translate and rotate the OGL state machine to desired rendering frame
if self.trnsByOGL:
glTranslated(
*self.pos3D
) # This moves the origin of drawing , so that we can use the above coordinates at each draw location
# ( Rotation is not applicable to points )
# [2]. Set color & size
glColor3ub(*self.colors[0])
glPointSize(self.size)
# [3]. Render!
# print "DEBUG ," , "self.vertX: " , self.vertX
# print "DEBUG ," , "self.indices:" , self.indices
pyglet.graphics.draw_indexed(
1, # --------------------- Number of seqential triplet in vertex list
GL_POINTS, # ------------- Draw quadrilaterals
self.
indices, # ----------------- Indices where the coordinates are stored
(
'v3f', self.vertX
) # -- vertex list , OpenGL offers an optimized vertex list object , but this is not it
)
# [4]. If OGL transforms enabled , Translate and rotate the OGL state machine to desired rendering frame
# ( Rotation is not applicable to points )
if self.trnsByOGL:
glTranslated(*np.multiply(self.pos3D,
-1)) # Reset the transform coordinates
def on_draw(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glColor3ub(255,255,255)
self.heading.draw()
for row in self.items:
for item in row:
item.draw()
def draw_palette(self):
pyglet.graphics.draw(4, gl.GL_QUADS,
("v2i", (0, 0, 0, 33, 32, 33, 32, 0)),
("c3B", self.left_color*4))
pyglet.graphics.draw(4, gl.GL_QUADS,
("v2i", (33, 0, 33, 33, 65, 33, 65, 0)),
("c3B", self.right_color*4))
if self.palette:
swatches = []
for x, y in self.swatch_loc:
swatches.extend((x, y, x, y+16, x+16, y+16, x+16, y))
for x, y in self.swatch2_loc:
swatches.extend((x, y, x, y+16, x+16, y+16, x+16, y))
sw_color = []
for color in self.palette[::2]:
sw_color.extend(color*4)
for color in self.palette[1::2]:
sw_color.extend(color*4)
pyglet.graphics.draw(4*len(self.palette), gl.GL_QUADS,
("v2i", swatches),
("c3B", sw_color))
x, y = self.tool_loc[-1][0]+35, self.tool_loc[-1][1]
pyglet.graphics.draw(4, gl.GL_QUADS,
("v2i", (x, y, x, y+32, x+32, y+32, x+32, y)),
("c3B", self.background_color*4))
gl.glColor3ub(255,255,255)
def on_draw(self):
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glColor3ub(255, 255, 255)
self.heading.draw()
for row in self.items:
for item in row:
item.draw()
def draw(self):
gl.glColor3ub(255,30,30)
gl.glRecti(*(self.p1+self.p2))
gl.glColor3ub(150,255,45)
gl.glRecti(*(self.p1+self.p3))
#gl.glColor3ub(255,255,255)
self.text.draw()
def drawRect(grey, win):
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub( grey[0], grey[1], grey[2] )
gl.glVertex2f(0,0)
gl.glVertex2f(win.width, 0)
gl.glVertex2f(win.width, win.height)
gl.glVertex2f(0, win.height)
gl.glEnd()
def draw_rectangle(x1, y1, x2, y2): # vykreslí výplň stěn
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(102, 0, 51)
gl.glVertex2f(x1, y1)
gl.glVertex2f(x1, y2)
gl.glVertex2f(x2, y2)
gl.glVertex2f(x2, y1)
gl.glEnd()
def draw_background(x1, y1, x2, y2): # vykreslí pozadí hry
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(0, 0, 40)
gl.glVertex2f(x1, y1)
gl.glVertex2f(x1, y2)
gl.glVertex2f(x2, y2)
gl.glVertex2f(x2, y1)
gl.glEnd()
def display_pointer(angle, color, radius):
x_value = math.cos(angle)
y_value = math.sin(angle)
glBegin(GL_LINES)
glColor3ub(*color)
glVertex2f(0.0, 0.0)
glVertex2f(x_value * radius, y_value * radius)
glEnd()
def display_pointer(angle, color, radius):
x_value = math.cos(angle)
y_value = math.sin(angle)
glBegin(GL_LINES)
glColor3ub(*color)
glVertex2f(0.0, 0.0)
glVertex2f(x_value * radius, y_value * radius)
glEnd()
def drawRect(grey, win):
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(grey[0], grey[1], grey[2])
gl.glVertex2f(0, 0)
gl.glVertex2f(win.width, 0)
gl.glVertex2f(win.width, win.height)
gl.glVertex2f(0, win.height)
gl.glEnd()
def draw_red_square():
gl.glColor3ub(127, 0, 0)
gl.glBegin(gl.GL_QUADS)
gl.glVertex2f(-10, -10)
gl.glVertex2f(10, -10)
gl.glVertex2f(10, 10)
gl.glVertex2f(-10, 10)
gl.glEnd()
def draw_outline(x1, y1, x2, y2): # vykreslí stěny
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(255, 0, 102)
gl.glVertex2f(x1, y1)
gl.glVertex2f(x1, y2)
gl.glVertex2f(x2, y2)
gl.glVertex2f(x2, y1)
gl.glEnd()
def render_rect_filled(shape, offset):
""" Render the shape at the right spot. """
# Set color
GL.glLoadIdentity()
GL.glColor3ub(shape.color[0], shape.color[1], shape.color[2])
GL.glTranslatef(shape.x + shape.width / 2, shape.y + shape.height / 2, 0)
GL.glDrawArrays(GL.GL_QUADS, offset, 4)
def draw(self):
if not self.visible:
return
gl.glLineWidth(2) # deprecated
gl.glColor3ub(*self.color3)
gl.glBegin(gl.GL_LINE_STRIP)
for v in self.vertexes:
gl.glVertex2f(*v)
gl.glVertex2f(*self.vertexes[0])
gl.glEnd()
def plot_box(minx, maxx, miny, maxy):
# gl is using default origin in bottom right
gl.glColor3ub(*COLOR_BOX)
gl.glBegin(gl.GL_LINE_STRIP)
#vertexes = [(0.0, 0.0), (0.0, window.height//2), (window.width//2, window.height//2), (window.width//2, 0.0)]
vertexes = [(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)]
for v in vertexes:
gl.glVertex2f(*v)
gl.glVertex2f(*vertexes[0])
gl.glEnd()
def draw(self):
if not self.visible:
return
gl.glLineWidth(2) # deprecated
gl.glColor3ub(*self.color3)
gl.glBegin(gl.GL_LINE_STRIP)
for v in self.vertexes:
gl.glVertex2f(*v)
gl.glVertex2f(*self.vertexes[0])
gl.glEnd()
def draw_points(x1, y1, x2, y2, x3, y3, x4, y4): # vykreslí tečky
global k
gl.glBegin(gl.GL_TRIANGLE_FAN)
gl.glColor3ub(0 + int(102 * k), 77 + int(142 * k), 102 + int(153 * k))
# pomocí koeficientu k měníme barvu (viditelnost) teček
gl.glVertex2f(x1, y1)
gl.glVertex2f(x2, y2)
gl.glVertex2f(x3, y3)
gl.glVertex2f(x4, y4)
gl.glEnd()
def render_slow(self):
self.disp_list = gl.glGenLists(1)
gl.glNewList(self.disp_list, gl.GL_COMPILE)
for x in range(ROOM_X):
for y in range(ROOM_Y):
square = self[x,y]
if square.material and square.material.visible and square.material.texture != None:
gl.glColor3ub(*square.material.colour)
square.material.texture.blit(x*16,y*16)
gl.glEndList()
def plot_box(bottom_left_x, bottom_left_y, width, height):
COLOR_BOX = (0, 0, 255)
gl.glColor3ub(*COLOR_BOX)
gl.glBegin(gl.GL_LINE_STRIP)
top_right_x = bottom_left_x + width
top_right_y = bottom_left_y + height
vertexes = [(bottom_left_x, bottom_left_y), (bottom_left_x, top_right_y),
(top_right_x, top_right_y), (top_right_x, bottom_left_y)]
for v in vertexes:
gl.glVertex2f(*v)
gl.glVertex2f(*vertexes[0])
gl.glEnd()
def draw_block(self, block):
glBegin(GL_TRIANGLE_FAN)
glColor3ub(
int(block.material.color[0] * 0.25),
int(block.material.color[1] * 0.25),
int(block.material.color[2] * 0.25),
)
glVertex2f(0, 0)
glColor3ub(*block.material.color)
for idx in range(len(block.verts)):
glVertex2f(*block.verts[idx])
glVertex2f(*block.verts[0])
glEnd()
def draw(self):
""" Draws all of the tiles and tray """
gl.glPushMatrix()
gl.glTranslated(self.rect.x, self.rect.y, 0)
for y in range(self.height):
for x in range(self.width):
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(*[30 + ((x + y) % 2) * 50] * 3)
gl.glVertex2f(x * TILE_SIZE * self.scale,
y * TILE_SIZE * self.scale)
gl.glVertex2f((x + 1) * TILE_SIZE * self.scale,
y * TILE_SIZE * self.scale)
gl.glVertex2f((x + 1) * TILE_SIZE * self.scale,
(y + 1) * TILE_SIZE * self.scale)
gl.glVertex2f(x * TILE_SIZE * self.scale,
(y + 1) * TILE_SIZE * self.scale)
gl.glEnd()
for y in range(self.height):
for x in range(self.width):
if self(x, y):
self(x, y).draw((x + 0.5) * TILE_SIZE * self.scale,
(y + 0.5) * TILE_SIZE * self.scale,
self.scale)
if self(x, y).highlighted:
gl.glBegin(gl.GL_QUADS)
gl.glColor4ub(*[255, 0, 0, 180])
gl.glVertex2f(x * TILE_SIZE * self.scale,
y * TILE_SIZE * self.scale)
gl.glVertex2f((x + 1) * TILE_SIZE * self.scale,
y * TILE_SIZE * self.scale)
gl.glVertex2f((x + 1) * TILE_SIZE * self.scale,
(y + 1) * TILE_SIZE * self.scale)
gl.glVertex2f(x * TILE_SIZE * self.scale,
(y + 1) * TILE_SIZE * self.scale)
gl.glEnd()
row = 0
col = 0
for tile in self.tray:
if col == self.tray_cols:
col = 0
row += 1
x = self.tray_start_x + ((col + 0.5) * self.tray_cols_width)
y = self.rect.height - ((row + 0.5) * self.tray_cols_width)
tile.draw(x, y, TRAY_SCALE * self.scale * 9 / 10)
col += 1
gl.glPopMatrix()
if self.dragging:
self.dragging.draw(self.dragging.x, self.dragging.y,
self.scale * DRAG_SCALE)
def draw(self, scale, pos):
LINE_COLOUR = (255, 255, 255)
# gl.glEnable(gl.GL_DEPTH_TEST);
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_DONT_CARE)
gl.glBegin(gl.GL_LINES)
for link in self.links:
if link.highlight:
gl.glColor3ub(*self.colour)
gl.glColor3ub(*self.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
if link.highlight:
depth = 0.5
else:
depth = 0.5
gl.glVertex3f(*util.add_tup(pos, util.scale_tup(link.points[0].pos, scale)) + (depth,))
gl.glVertex3f(*util.add_tup(pos, util.scale_tup(link.points[1].pos, scale)) + (depth,))
print util.add_tup(pos, util.scale_tup(link.points[0].pos, scale))
gl.glEnd()
def on_draw(self):
self.fenetre3d.clear()
#pgl.glPushMatrix()
#pgl.glRotatef(self.fenetre3d.xRotation, 0, 1, 0)
#pgl.glRotatef(0, 0, 1, 1)
pgl.glBegin(ogl.GL_QUADS)
#bleu
pgl.glColor3ub(0, 0, 255)
pgl.glVertex3f(0, 0, 0)
pgl.glVertex3f(0, 10, 0)
pgl.glVertex3f(self.arene.nb_colonne, 10, 0)
pgl.glVertex3f(self.arene.nb_colonne, 0, 0)
#rouge
pgl.glColor3ub(255, 0, 0)
pgl.glVertex3f(self.arene.nb_colonne, 0, 0)
pgl.glVertex3f(self.arene.nb_colonne, 10, 0)
pgl.glVertex3f(self.arene.nb_colonne, 10, self.arene.nb_ligne)
pgl.glVertex3f(self.arene.nb_colonne, 0, self.arene.nb_ligne)
#vert
pgl.glColor3ub(0, 255, 0)
pgl.glVertex3f(0, 0, self.arene.nb_ligne)
pgl.glVertex3f(0, 10, self.arene.nb_ligne)
pgl.glVertex3f(self.arene.nb_colonne, 10, self.arene.nb_ligne)
pgl.glVertex3f(self.arene.nb_colonne, 0, self.arene.nb_ligne)
#jaune
pgl.glColor3ub(255, 255, 0)
pgl.glVertex3f(00, 0, 00)
pgl.glVertex3f(00, 10, 00)
pgl.glVertex3f(00, 10, self.arene.nb_ligne)
pgl.glVertex3f(00, 0, self.arene.nb_ligne)
#blanc
pgl.glColor3ub(255, 255, 255)
pgl.glVertex3f(00, 0, self.arene.nb_ligne)
pgl.glVertex3f(00, 0, 0)
pgl.glVertex3f(self.arene.nb_colonne, 0, 0)
pgl.glVertex3f(self.arene.nb_colonne, 0, self.arene.nb_ligne)
self.draw()
pgl.glEnd()
"""Permet de faire un screenshot"""
kitten = pyglet.image.load('balise2.png')
sprite = pyglet.sprite.Sprite(kitten)
sprite.set_position(00, 80)
sprite.draw()
pyglet.image.get_buffer_manager().get_color_buffer().save(
'screenshot.png')
pgl.glFlush()
def draw(self, scale, pos):
LINE_COLOUR = (255, 255, 255)
#gl.glEnable(gl.GL_DEPTH_TEST);
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_DONT_CARE)
gl.glBegin(gl.GL_LINES)
for link in self.links:
if link.highlight:
gl.glColor3ub(*self.colour)
gl.glColor3ub(*self.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
if link.highlight:
depth = 0.5
else:
depth = 0.5
gl.glVertex3f(
*util.add_tup(pos, util.scale_tup(link.points[0].pos, scale)) +
(depth, ))
gl.glVertex3f(
*util.add_tup(pos, util.scale_tup(link.points[1].pos, scale)) +
(depth, ))
print util.add_tup(pos, util.scale_tup(link.points[0].pos, scale))
gl.glEnd()
def draw_filled_circle(position, size=20, num_of_segments=30, color=None):
if color is None:
glColor3ub(255, 0, 0)
else:
glColor3f(*color)
twice_pi = 2.0 * 3.141596
glBegin(GL_TRIANGLE_FAN)
glVertex2f(position.x, position.y)
for i in range(num_of_segments + 1):
glVertex2f(
(position.x + (size * math.cos(i * twice_pi / num_of_segments))),
(position.y + (size * math.sin(i * twice_pi / num_of_segments))))
glEnd()
def draw_rooms(self, rooms):
for room in rooms.itervalues():
glColor3ub(*room.color)
glBegin(GL_TRIANGLE_FAN)
for vert in room.verts:
glVertex2f(*vert)
glEnd()
for room in rooms.itervalues():
glColor3ub(255, 255, 255)
glBegin(GL_LINES)
for idx in xrange(len(room.verts)):
if idx not in room.neighbours:
glVertex2f(*room.verts[idx])
nextidx = (idx + 1) % len(room.verts)
glVertex2f(*room.verts[nextidx])
glEnd()
def draw(self):
gl.glColor3ub(*self.col)
gl.glBegin(gl.GL_LINE_LOOP)
gl.glVertex2f(int(self.rect.x),int(self.rect.y))
gl.glVertex2f(int(self.rect.x),int(self.rect.y+self.rect.height))
gl.glVertex2f(int(self.rect.x+self.rect.width),int(self.rect.y+self.rect.height))
gl.glVertex2f(int(self.rect.x+self.rect.width),int(self.rect.y))
gl.glEnd()
gl.glBegin(gl.GL_QUADS)
gl.glVertex2f(int((self.rect.x)*self.filled),int(self.rect.y))
gl.glVertex2f(int((self.rect.x)*self.filled),int(self.rect.y+self.rect.height))
gl.glVertex2f(int((self.rect.x+self.rect.width)*self.filled),int(self.rect.y+self.rect.height))
gl.glVertex2f(int((self.rect.x+self.rect.width)*self.filled),int(self.rect.y))
gl.glEnd()
self.label.draw()
def draw(self):
grid = self._grid
live = []
dead = []
for x, y, value in self._creator.flat:
if value:
live.extend(grid[x, y])
else:
dead.extend(grid[x, y])
gl.glColor3ub(*LIVE_COLOR)
graphics.draw(len(live) // 2, gl.GL_QUADS, ('v2i', live))
gl.glColor3ub(*DEAD_COLOR)
graphics.draw(len(dead) // 2, gl.GL_QUADS, ('v2i', dead))
def plot_test_box():
gl.glColor3ub(*COLOR_BOX)
gl.glBegin(gl.GL_LINE_STRIP)
vertexes = [(0.0, 0.0), (0.0, window.height // 2),
(window.width // 2, window.height // 2),
(window.width // 2, 0.0)]
for v in vertexes:
gl.glVertex2f(*v)
gl.glVertex2f(*vertexes[0])
gl.glEnd()
label = pyglet.text.Label('Hello, world',
font_name='Times New Roman',
font_size=36,
x=window.width // 2,
y=window.height // 2,
anchor_x='center',
anchor_y='center')
label.draw()
def _draw_rect(self, backColor, polyColor, left, bottom, right, top):
glClearColor(
backColor[0]/255,
backColor[1]/255,
backColor[2]/255,
1.0)
self.window.clear()
verts = [
(left, bottom),
(right, bottom),
(right, top),
(left, top),
]
glColor3ub(*polyColor)
glBegin(GL_TRIANGLE_FAN)
for vert in verts:
glVertex2f(*vert)
glEnd()
def draw_triangle(position, velocity, size=20, color=None):
glPushMatrix()
glTranslatef(position.x, position.y, 0.0)
glRotatef(math.degrees(math.atan2(velocity.x, velocity.y)), 0.0, 0.0, -1.0)
glBegin(GL_TRIANGLES)
if color is None:
glColor3ub(255, 0, 0)
else:
glColor3f(*color)
glVertex2f(size, 0.0)
glVertex2f(-size, 0.0)
glVertex2f(0.0, size * 3.0)
glEnd()
glPopMatrix()
def draw(self):
gl.glColor3ub(*self.col)
gl.glBegin(gl.GL_LINE_LOOP)
gl.glVertex2f(int(self.rect.x), int(self.rect.y))
gl.glVertex2f(int(self.rect.x), int(self.rect.y + self.rect.height))
gl.glVertex2f(int(self.rect.x + self.rect.width),
int(self.rect.y + self.rect.height))
gl.glVertex2f(int(self.rect.x + self.rect.width), int(self.rect.y))
gl.glEnd()
gl.glBegin(gl.GL_QUADS)
gl.glVertex2f(int((self.rect.x) * self.filled), int(self.rect.y))
gl.glVertex2f(int((self.rect.x) * self.filled),
int(self.rect.y + self.rect.height))
gl.glVertex2f(int((self.rect.x + self.rect.width) * self.filled),
int(self.rect.y + self.rect.height))
gl.glVertex2f(int((self.rect.x + self.rect.width) * self.filled),
int(self.rect.y))
gl.glEnd()
self.label.draw()
def draw(self):
""" Draws all of the tiles and tray """
gl.glPushMatrix()
gl.glTranslated(self.rect.x,self.rect.y,0)
for y in range(self.height):
for x in range(self.width):
gl.glBegin(gl.GL_QUADS)
gl.glColor3ub(*[30+((x+y)%2)*50]*3)
gl.glVertex2f(x*TILE_SIZE*self.scale,y*TILE_SIZE*self.scale)
gl.glVertex2f((x+1)*TILE_SIZE*self.scale,y*TILE_SIZE*self.scale)
gl.glVertex2f((x+1)*TILE_SIZE*self.scale,(y+1)*TILE_SIZE*self.scale)
gl.glVertex2f(x*TILE_SIZE*self.scale,(y+1)*TILE_SIZE*self.scale)
gl.glEnd()
for y in range(self.height):
for x in range(self.width):
if self(x,y):
self(x,y).draw((x+0.5)*TILE_SIZE*self.scale,(y+0.5)*TILE_SIZE*self.scale,self.scale)
if self(x,y).highlighted:
gl.glBegin(gl.GL_QUADS)
gl.glColor4ub(*[255,0,0,180])
gl.glVertex2f(x*TILE_SIZE*self.scale,y*TILE_SIZE*self.scale)
gl.glVertex2f((x+1)*TILE_SIZE*self.scale,y*TILE_SIZE*self.scale)
gl.glVertex2f((x+1)*TILE_SIZE*self.scale,(y+1)*TILE_SIZE*self.scale)
gl.glVertex2f(x*TILE_SIZE*self.scale,(y+1)*TILE_SIZE*self.scale)
gl.glEnd()
row = 0
col = 0
for tile in self.tray:
if col == self.tray_cols:
col = 0
row += 1
x = self.tray_start_x + ((col+0.5)*self.tray_cols_width)
y = self.rect.height - ((row+0.5)*self.tray_cols_width)
tile.draw(x,y,TRAY_SCALE*self.scale*9/10)
col += 1
gl.glPopMatrix()
if self.dragging: self.dragging.draw(self.dragging.x,self.dragging.y,self.scale*DRAG_SCALE)
def draw(self): self.back.draw(self.rect) k = self._expression() if self._inrect is None or k != self._expRes: self._inrect = self.rect.clone().inset(5).scale(scaleX=k,scaleY=1,origin=self._grow_origin) self._expRes = k if k > 0: if k < 0.4: gl.glColor3ub(255,0,0) elif k < 0.7: gl.glColor3ub(255,255,0) else: gl.glColor3ub(0,255,0) self.front.draw(self._inrect) gl.glColor3ub(255,255,255)
def draw(self):
self.back.draw(self.rect)
k = self._expression()
if self._inrect is None or k != self._expRes:
self._inrect = self.rect.clone().inset(5).scale(
scaleX=k, scaleY=1, origin=self._grow_origin)
self._expRes = k
if k > 0:
if k < 0.4:
gl.glColor3ub(255, 0, 0)
elif k < 0.7:
gl.glColor3ub(255, 255, 0)
else:
gl.glColor3ub(0, 255, 0)
self.front.draw(self._inrect)
gl.glColor3ub(255, 255, 255)
def draw_disc(self, disc):
num_tris = 32
x, y = disc.get_offset()
glBegin(GL_TRIANGLE_FAN)
darker = (
int(disc.material.color[0] * 0.75),
int(disc.material.color[1] * 0.75),
int(disc.material.color[2] * 0.75),
)
glColor3ub(0, 0, 0)
glVertex2f(x, y)
col_freq = 4
for idx in range(num_tris + 1):
if idx % (col_freq * 2) == 0:
glColor3ub(*disc.material.color)
elif (idx + col_freq) % col_freq == 0:
glColor3ub(*darker)
theta = 2 * pi / num_tris * idx
glVertex2f(
x + disc.radius * sin(theta),
y + disc.radius * cos(theta))
glEnd()
def draw(self):
for i in self.arene.list_obj:
i.hauteur = 50
# Debut du dessin
#pgl.glBegin(ogl.GL_QUADS)
x = i.x - i.largeur // 2
y = i.y - i.longueur // 2
# Premier carre rouge de derrier
pgl.glColor3ub(255, 0, 0)
pgl.glVertex3f(x, 0, y)
pgl.glVertex3f(x, i.hauteur, y)
pgl.glVertex3f(x + i.largeur, i.hauteur, y)
pgl.glVertex3f(x + i.largeur, 0, y)
# Second carre bleu de gauche
pgl.glColor3ub(0, 0, 255)
pgl.glVertex3f(x, 0, y)
pgl.glVertex3f(x, i.hauteur, y)
pgl.glVertex3f(x, i.hauteur, y + i.longueur)
pgl.glVertex3f(x, 0, y + i.longueur)
# Troisieme carre vert du dessous
pgl.glColor3ub(0, 255, 0)
pgl.glVertex3f(x, 0, y)
pgl.glVertex3f(x + i.largeur, 0, y)
pgl.glVertex3f(x + i.largeur, 0, y + i.longueur)
pgl.glVertex3f(x, 0, y + i.longueur)
# Quatrieme carre rose de droite
pgl.glColor3ub(255, 0, 255)
pgl.glVertex3f(x + i.largeur, 0, y)
pgl.glVertex3f(x + i.largeur, i.hauteur, y)
pgl.glVertex3f(x + i.largeur, i.hauteur, y + i.longueur)
pgl.glVertex3f(x + i.largeur, 0, y + i.longueur)
# Cinquieme carre gris fclair du haut
pgl.glColor3ub(122, 122, 122)
pgl.glVertex3f(x, i.hauteur, y)
pgl.glVertex3f(x + i.largeur, i.hauteur, y)
pgl.glVertex3f(x + i.largeur, i.hauteur, y + i.longueur)
pgl.glVertex3f(x, i.hauteur, y + i.longueur)
# Sixieme face fonce
pgl.glColor3ub(40, 40, 40)
pgl.glVertex3f(x, 0, y + i.longueur)
pgl.glVertex3f(x, i.hauteur, y + i.longueur)
pgl.glVertex3f(x + i.largeur, i.hauteur, y + i.longueur)
pgl.glVertex3f(x + i.largeur, 0, y + i.longueur)
def on_draw(self):
self.clear()
if CENTER_ON:
gl.glBegin(gl.GL_POLYGON)
for delta in POINT_DELTAS:
gl.glColor3ub(*CENTER_COLOUR)
gl.glVertex2f(
*util.add_tup(self.vector_to_screen(0, 0), delta))
gl.glEnd()
if GRID_ON:
gl.glBegin(gl.GL_LINES)
for x in range(-int(self.view_size[0] / GRID_SIZE),
int(self.view_size[0] / GRID_SIZE)):
gl.glColor3ub(*GRID_COLOUR)
gl.glColor3ub(*GRID_COLOUR)
gl.glVertex2f(
*self.vector_to_screen(x * GRID_SIZE, -self.view_size[1] /
2))
gl.glVertex2f(
*self.vector_to_screen(x * GRID_SIZE, +self.view_size[1] /
2))
for y in range(-int(self.view_size[1] / GRID_SIZE),
int(self.view_size[1] / GRID_SIZE)):
gl.glColor3ub(*GRID_COLOUR)
gl.glColor3ub(*GRID_COLOUR)
gl.glVertex2f(*self.vector_to_screen(-self.view_size[0] /
2, y * GRID_SIZE))
gl.glVertex2f(*self.vector_to_screen(+self.view_size[0] /
2, y * GRID_SIZE))
gl.glEnd()
gl.glBegin(gl.GL_LINES)
for link in self.vector.links:
if link.highlight:
gl.glColor3ub(*self.vector.colour)
gl.glColor3ub(*self.vector.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
gl.glVertex2f(*self.vector_to_screen(*link.points[0].pos))
gl.glVertex2f(*self.vector_to_screen(*link.points[1].pos))
gl.glEnd()
for point in self.vector.points:
gl.glBegin(gl.GL_POLYGON)
if point == self.hover_point:
for x in range(4):
gl.glColor3ub(*POINT_HOVER_COLOUR)
elif point == self.active_point:
for x in range(4):
gl.glColor3ub(*POINT_ACTIVE_COLOUR)
else:
for x in range(4):
gl.glColor3ub(*POINT_COLOUR)
for delta in POINT_DELTAS:
gl.glVertex2f(*util.add_tup(self.vector_to_screen(
*point.pos), delta))
gl.glEnd()
def on_draw(self):
self.clear()
if CENTER_ON:
gl.glBegin(gl.GL_POLYGON)
for delta in POINT_DELTAS:
gl.glColor3ub(*CENTER_COLOUR)
gl.glVertex2f(*util.add_tup(self.vector_to_screen(0,0),delta))
gl.glEnd()
if GRID_ON:
gl.glBegin(gl.GL_LINES)
for x in range(-int(self.view_size[0]/GRID_SIZE),int(self.view_size[0]/GRID_SIZE)):
gl.glColor3ub(*GRID_COLOUR)
gl.glColor3ub(*GRID_COLOUR)
gl.glVertex2f(*self.vector_to_screen(x*GRID_SIZE,-self.view_size[1]/2))
gl.glVertex2f(*self.vector_to_screen(x*GRID_SIZE,+self.view_size[1]/2))
for y in range(-int(self.view_size[1]/GRID_SIZE),int(self.view_size[1]/GRID_SIZE)):
gl.glColor3ub(*GRID_COLOUR)
gl.glColor3ub(*GRID_COLOUR)
gl.glVertex2f(*self.vector_to_screen(-self.view_size[0]/2,y*GRID_SIZE))
gl.glVertex2f(*self.vector_to_screen(+self.view_size[0]/2,y*GRID_SIZE))
gl.glEnd()
gl.glBegin(gl.GL_LINES)
for link in self.vector.links:
if link.highlight:
gl.glColor3ub(*self.vector.colour)
gl.glColor3ub(*self.vector.colour)
else:
gl.glColor3ub(*LINE_COLOUR)
gl.glColor3ub(*LINE_COLOUR)
gl.glVertex2f(*self.vector_to_screen(*link.points[0].pos))
gl.glVertex2f(*self.vector_to_screen(*link.points[1].pos))
gl.glEnd()
for point in self.vector.points:
gl.glBegin(gl.GL_POLYGON)
if point == self.hover_point:
for x in range(4): gl.glColor3ub(*POINT_HOVER_COLOUR)
elif point == self.active_point:
for x in range(4): gl.glColor3ub(*POINT_ACTIVE_COLOUR)
else:
for x in range(4): gl.glColor3ub(*POINT_COLOUR)
for delta in POINT_DELTAS:
gl.glVertex2f(*util.add_tup(self.vector_to_screen(*point.pos),delta))
gl.glEnd()
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_ghost(x, y,
ghost): # nakreslí příšerku s barvou podle argumentu ghost
global EYES, c
if ghost == 0:
r = 255
g = 1
b = 1
if ghost == 1:
r = 1
g = 255
b = 1
if ghost == 2:
r = 1
g = 1
b = 255
if ghost == 3:
r = 255
g = 1
b = 255
if ghost == 4:
r = 255
g = 1
b = 125
if ghost == 5:
r = 0
g = 205
b = 205
color = (r, g, b)
ghost = pyglet.shapes.Circle(x + 20, y + 24, 15, color=color, batch=batch)
ghost.draw()
gl.glBegin(gl.GL_POLYGON)
gl.glColor3ub(r, g, b)
gl.glVertex2f(x + 20, y + 30)
gl.glVertex2f(x + 35, y + 25)
gl.glVertex2f(x + 35, y + 4)
gl.glVertex2f(x + 27.5, y + 11.5)
gl.glVertex2f(x + 20, y + 4)
gl.glVertex2f(x + 12.5, y + 11.5)
gl.glVertex2f(x + 5, y + 4)
gl.glVertex2f(x + 5, y + 25)
gl.glEnd()
c = sin(EYES) # pohyb očí opět pomocí funkce sinus
# pomocí koeficientu c se mění x-ová souřadnice očí - pohyb ze strany na stranu
eye1 = pyglet.shapes.Circle((x + 13) + c * 4,
y + 24,
6.5,
segments=15,
color=(255, 255, 255),
batch=batch) # levé oko
eye2 = pyglet.shapes.Circle((x + 27) + c * 4,
y + 24,
6.5,
segments=15,
color=(255, 255, 255),
batch=batch) # pravé oko
pupil1 = pyglet.shapes.Circle((x + 13) + c * 8,
y + 24,
3,
segments=10,
color=(1, 1, 1),
batch=batch) # levá zornička
pupil2 = pyglet.shapes.Circle((x + 27) + c * 8,
y + 24,
3,
segments=10,
color=(1, 1, 1),
batch=batch) # pravá zornička
eye1.draw()
eye2.draw()
pupil1.draw()
pupil2.draw()
def draw_pacman(): # nakreslí pacmana včetně pohybu úst
global PACMAN_DIRECTION, MOUTH, MOUTH_DIRECTION
if PACMAN_DIRECTION > 0:
MOUTH_DIRECTION = PACMAN_DIRECTION
pacman = pyglet.shapes.Circle(
position_pacman[0] + 20,
position_pacman[1] + 20,
16,
color=(255, 255, 1),
batch=batch,
)
pacman.draw()
if status != 6: # pokud není pozastavená hra, ústa se hýbou
MOUTH += 0.25
if MOUTH > pi: # pokud je větší než π, resetuje se na 0
# zajistí tak plynulé otevírání a zavírání úst pomocí funkce sinus níže
MOUTH = 0
# otevírání a zavírání úst podle směru Pac-Mana
if status != 4: # pokud hráč nezemřel, ústa se hýbou
n = sin(MOUTH) # koeficientem k a funkcí sinus se násobí souřadnice
# Pac-manových úst --> zavírání a otevírání úst
x1, y1 = position_pacman[0] + 20, position_pacman[1] + 20
x2, y2, x3, y3 = 1, 1, 1, 1
if MOUTH_DIRECTION == 1: # pokud jsou ústa nasměrována doprava
x2 = position_pacman[0] + 36
x3 = position_pacman[0] + 36
y = position_pacman[1] + 20
y2, y3 = y - 20 * n, y + 20 * n
if MOUTH_DIRECTION == 2: # dolů
x = position_pacman[0] + 20
x2 = x - 20 * n
x3 = x + 20 * n
y2 = position_pacman[1] + 36
y3 = position_pacman[1] + 36
if MOUTH_DIRECTION == 3: # doleva
x2 = position_pacman[0] + 4
x3 = position_pacman[0] + 4
y = position_pacman[1] + 20
y2, y3 = y - 20 * n, y + 20 * n
if MOUTH_DIRECTION == 4: # nahoru
x = position_pacman[0] + 20
x2 = x - 20 * n
x3 = x + 20 * n
y2 = position_pacman[1] + 4
y3 = position_pacman[1] + 4
# vykreslení úst
gl.glBegin(gl.GL_TRIANGLES)
gl.glColor3ub(0, 0, 40)
gl.glVertex2f(x1, y1)
gl.glVertex2f(x2, y2)
gl.glVertex2f(x3, y3)
gl.glEnd()
if status == 4: # pokud hráč umřel
dead_eye1 = pyglet.shapes.Rectangle(
position_pacman[0] + 13,
position_pacman[1] + 24,
4,
4,
color=(1, 1, 1),
)
dead_eye1.rotation = 45
dead_eye1.draw()
dead_eye2 = pyglet.shapes.Rectangle(
position_pacman[0] + 26,
position_pacman[1] + 24,
4,
4,
color=(1, 1, 1),
)
dead_eye2.rotation = 45
dead_eye2.draw()
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()
