def draw_lasers(self): batch = Batch() inner_colors = (0, 200, 255, 0, 200, 255) radius = 3 * SpaceWindow.BULLET_RADIUS_PERCENT * self.width for bullet in self.model.bullets: # self.draw_illumination(self.to_screen_x(bullet[0]), self.to_screen_y(bullet[1]), radius, inner_colors[:3]) batch.add(2, GL_LINES, None, ('v2f', [self.to_screen_x(bullet[0]), self.to_screen_y(bullet[1]), self.to_screen_x(bullet[0]), self.to_screen_y(bullet[1] + int(self.BULLET_HEIGHT_PERCENT * self.main_height))]), ('c3B', inner_colors)) radius = SpaceWindow.BULLET_RADIUS_PERCENT * self.width purple = [255, 0, 255] for x, y in self.model.alien_bullets: self.draw_illumination(self.to_screen_x(x), self.to_screen_y(y), 6 * radius, purple) circ_pts = [self.to_screen_x(x), self.to_screen_y(y) + radius] for theta in np.linspace(0, 2 * math.pi, 8): error = random.randint(-1 * radius // 4, radius // 4) circ_pts.extend([circ_pts[0] + (radius + error) * math.sin(theta), circ_pts[1] + (radius + error) * math.cos(theta)]) num_of_vert = (len(circ_pts) // 2) colors = [255, 255, 255] colors.extend((num_of_vert - 1) * purple) graphics.draw(num_of_vert, GL_TRIANGLE_FAN, ('v2f', circ_pts), ('c3B', colors)) batch.draw()
def draw(self): if self.text: width, height = len(self.text) * 7 + 20, 30 graphics.draw(4, gl.GL_QUADS, ("v2f", (0, 0, 0, height, width, height, width, 0)), ("c4f", (1, 1, 1, 1) * 4)) super(Printer, self).draw()
def _draw_local(self): draw(4, GL_LINES, ('v3f', list([ a + b for a, b in zip(self.cross_base, cycle(self.model.center_of_mass)) ])))
def drawRectangle( pos=(0, 0), size=(1.0, 1.0), ): data = (pos[0], pos[1], pos[0] + size[0], pos[1], pos[0] + size[0], pos[1] + size[1], pos[0], pos[1] + size[1]) draw(4, GL_QUADS, ('v2f', data))
def on_draw(self): self.window.clear() gl.glMatrixMode(gl.GL_PROJECTION) gl.glPushMatrix() gl.glLoadIdentity() self.camera() gl.glEnable(self.background.target) gl.glEnable(gl.GL_BLEND) gl.glBindTexture(self.background.target, self.background.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.background.target) for lane in self.world.lanes: self.draw_lane_surface(lane) self.draw_lane_lines(lane) for obj in self.world.objects: self.draw_object(obj) for car in self.world.cars: self.draw_car(car.trajectory[-1], car.color) gl.glPopMatrix() self.label.text = self.task_name self.label.draw() self.iter += 1 if self.iter % 10 == 0: print('Iterations: ', self.iter) if self.iter == self.max_iters: self.event_loop.exit()
def _draw_lane(self, lane: StraightLane): """Draws a `StraightLane`.""" # first, draw the asphalt gl.glColor3f(0.4, 0.4, 0.4) # set color to gray graphics.draw( 4, gl.GL_QUAD_STRIP, ( "v2f", np.hstack([ lane.p - 0.5 * lane.w * lane.n, lane.p + 0.5 * lane.w * lane.n, lane.q - 0.5 * lane.w * lane.n, lane.q + 0.5 * lane.w * lane.n, ]), ), ) # next, draw the white lines between lanes gl.glColor3f(1.0, 1.0, 1.0) # set color to white graphics.draw( 4, gl.GL_LINES, ( "v2f", np.hstack([ lane.p - 0.5 * lane.w * lane.n, lane.q - 0.5 * lane.w * lane.n, lane.p + 0.5 * lane.w * lane.n, lane.q + 0.5 * lane.w * lane.n, ]), ), )
def draw_lane_surface(self, lane): gl.glColor3f(0.4, 0.4, 0.4) W = 1000 graphics.draw(4, gl.GL_QUAD_STRIP, ('v2f', np.hstack([lane.p-lane.m*W-0.5*lane.w*lane.n, lane.p-lane.m*W+0.5*lane.w*lane.n, lane.q+lane.m*W-0.5*lane.w*lane.n, lane.q+lane.m*W+0.5*lane.w*lane.n]) ))
def draw_lane_lines(self, lane): gl.glColor3f(1., 1., 1.) W = 1000 graphics.draw(4, gl.GL_LINES, ('v2f', np.hstack([lane.p-lane.m*W-0.5*lane.w*lane.n, lane.p+lane.m*W-0.5*lane.w*lane.n, lane.p-lane.m*W+0.5*lane.w*lane.n, lane.p+lane.m*W+0.5*lane.w*lane.n]) ))
def drawFocusedBlock(self): block = self.game.world.hitTest(self.game.player.position, self.game.player.sightVector())[0] if block and self.game.world[block] != self.game.textures.edge: x, y, z, = block glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) draw(24, GL_QUADS, ('v3f/static', cube_vertices(x, y, z, 0.5),), ('c3B/static', (0, 0, 0,) * 24,)) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
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_reg_polygon(x, y, r, n, color=(255, 255, 255, 0)): vertices = [] th = 0 for _ in range(n): vertices += [x + r * sin(th), y + r * cos(th)] th += 2 * pi / n graphics.draw(n, gl.GL_POLYGON, ('v2f', vertices), ('c4B', color * n))
def updateSingleMaterial(self,shader,frame_buffer, prev_frame,material): with frame_buffer: self.window.clear();#abusive, but window.clear is apparently lazy as hell in pyglet, and will wipe our frame_buffer instead spread_rate=0.0 multiplier=1; if self.ticks%4==0: #multiplier=2 pass with UniformProvider(shader, previous_frame=prev_frame.textures[0], previous_status=prev_frame.textures[1], previous_velocity=prev_frame.textures[2], max_velocity=255.0, size=[float(self.start_texture.width*multiplier), float(self.start_texture.height*multiplier)], materialIndex=material.MatId, #move_direction=direction.stepVector, #colorTolerance=0.1, #being within a unit circle 1 wide from the target color is good enough #simulatedColor=material.color, #spread_rate=spread_rate, #max_spread=material.max_spread, ):#just have to know that this is how these buffers are arranged graphics.draw(6,TRIANGLE, square_2d )
def line(a, b, color=(1.0,1.0,1.0), width=1, aa=False, alpha=1.0): """ Draws a line from point *a* to point *b* using GL_LINE_STRIP optionaly with GL_LINE_SMOOTH when *aa=True* :param a: Point a :type a: 2-float tuple :param b: Point b :type b: 2-float tuple :param color: the color in [0..1] range :type color: 3-float tuple :param width: The with for glLineWidth() :param aa: Anti aliasing Flag :param alpha: the alpha value in [0..1] range """ glLineWidth(width) if aa: glEnable(GL_LINE_SMOOTH) draw(2,GL_LINES,('v2f',(a[0],a[1],b[0],b[1]) ) )
def draw_pause_menu(self): origin_x = self.width // 3 origin_y = self.height // 5 panel_width = self.width - 2 * origin_x panel_height = self.height - 2 * origin_y graphics.draw(4, GL_QUADS, [ 'v2f', [ origin_x, origin_y, origin_x, origin_y + panel_height, origin_x + panel_width, origin_y + panel_height, origin_x + panel_width, origin_y ] ], ['c4B', tuple(GameButton.DEF_COLOR)]) for btn in self.pause_btns: graphics.draw(4, GL_QUADS, [ 'v2f', [ btn.x - btn.width // 2, btn.y - btn.height // 2, btn.x - btn.width // 2, btn.y + btn.height // 2, btn.x + btn.width // 2, btn.y + btn.height // 2, btn.x + btn.width // 2, btn.y - btn.height // 2 ] ], ['c4B', tuple(btn.color)]) btn_lbl = pyglet.text.Label(btn.lbl, font_name='8Bit Wonder', font_size=0.3 * btn.height, width=btn.width, height=0.5 * btn.height, x=btn.x, y=btn.y, anchor_x='center', anchor_y='center', color=(255, 255, 255, btn.get_alpha())) btn_lbl.draw()
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 on_draw(): glClear(GL_COLOR_BUFFER_BIT) draw(3, GL_TRIANGLES, ('v2f', verts), ('c3B', colors), ) text.draw() clockDisplay.draw()
def drawTexturedRectangle(texture, pos=(0, 0), size=(1.0, 1.0)): glEnable(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, texture) pos = (pos[0], pos[1], pos[0] + size[0], pos[1], pos[0] + size[0], pos[1] + size[1], pos[0], pos[1] + size[1]) texcoords = (0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0) draw(4, GL_QUADS, ('v2f', pos), ('t2f', texcoords)) glDisable(GL_TEXTURE_2D)
def draw_grid(self): gl.glColor4f(0.23, 0.23, 0.23, 1.0) #Horizontal lines for i in range(rows): graphics.draw(2, gl.GL_LINES, ('v2i', (0, i * cell_size, window_width, i * cell_size))) #Vertical lines for j in range(columns): graphics.draw(2, gl.GL_LINES, ('v2i', (j * cell_size, 0, j * cell_size, window_height)))
def on_draw(): window.clear() glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(-wx, wx, -wy, wy, -20, 20) glRotatef(90, 1, 0, 0) graphics.draw(4, GL_QUADS, ('v3f', (v0 + v1 + v2 + v3)), ('t2f', t0 + t1 + t2 + t3))
def draw_shape_triangle(self, triangle, position): glPushMatrix() glTranslatef(position.x, position.y, 0) points = [] for point in triangle.points: points.extend((point.x, point.y)) draw(3, GL_LINE_LOOP, ('v2f', points)) glPopMatrix()
def draw(self, window): w, h = window.width/2, window.height/2 graphics.draw(2, gl.GL_LINES, ('v2f', [(self.origin[0]+w), (self.origin[1]+h), (self.endpoint[0]+w), (self.endpoint[1]+h)]), ('c3f', self.color*2))
def draw(self): indexed = [0, 1, 2, 1, 2, 3, 4, 5, 6] triangles = len(indexed) draw(triangles, pyglet.gl.GL_TRIANGLES, ("v3f", self.vertices[indexed,].flatten()), ("n3f", self.normals[indexed,].flatten()), ("c3B", self.color*triangles))
def draw_line(x1, y1, x2, y2, color=(255, 255, 255, 0)): """Draws a line from x1, y1 to x2, y2""" # 2 means that 2 vertices will be supplied, the mode is line drawing # v2i means (v)ertices, (2) coordinates per vertex ie 2D, each vertex is an (i)nteger # c3B means (c)olor, (4) values per vertex ie RGBA, unsigned (B)yte representation # there has to be one color per vertex, so in this case 2 lots of 4 values graphics.draw(2, gl.GL_LINES, ('v2i', (x1, y1, x2, y2)), ('c4B', color * 2))
def draw_shape_aabb(self, aabb, position): glPushMatrix() glTranslatef(position.x, position.y, 0) x_min, y_min, x_max, y_max = \ aabb.min.x, aabb.min.y, aabb.max.x, aabb.max.y draw(4, GL_LINE_LOOP, ('v2f', (x_min, y_min, x_min, y_max, x_max, y_max, x_max, y_min))) glPopMatrix()
def draw(self): indexed = [0, 1, 2, 1, 2, 3, 4, 5, 6] triangles = len(indexed) draw(triangles, pyglet.gl.GL_TRIANGLES, ("v3f", self.vertices[indexed, ].flatten()), ("n3f", self.normals[indexed, ].flatten()), ("c3B", self.color * triangles))
def render(self): if (self.toggled): glColor4f(*const.COLOR_BUTTON_TOGGLED) else: glColor4f(*const.COLOR_BUTTON) draw(4, GL_QUADS, ('v2f', self.gl_vertices)) glColor4f(*const.COLOR_BUTTON_BORDER) draw(4, GL_LINE_LOOP, ('v2f', self.gl_vertices)) self.label.draw()
def draw_shape_polygon(self, polygon, position): glPushMatrix() glTranslatef(position.x, position.y, 0) points = polygon.points p = [] for point in points: p.extend((point.x, point.y)) draw(len(points), GL_TRIANGLE_FAN, ('v2f', p)) glPopMatrix()
def _draw_bbox(bbox, color: Tuple[int, int, int, int]=None): color = color or (255, 255, 255, 255) lines = bbox.lines v3f = [(line.x1, -10.0, line.y1, line.x2, -10.0, line.y2) for line in lines] v3f = list(chain(*v3f)) n_points = int(len(v3f) / 3) v3f = ('v3f', v3f) c4b = ('c4B', color * n_points) draw(n_points, GL_LINES, v3f, c4b)
def render(self): self.w.batches["mm_buttons"].draw() gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glColor3f(0.3, 0.3, 0.3, 1) for e in self.entries: graphics.draw( 4, gl.GL_QUADS, ('v2i', e.rectangle) ) e.label.draw()
def drawCover(texture, pos=(0,0), size=(1.0,1.0)): with gx_texture(texture): pos = ( pos[0],pos[1], pos[0]+size[0],pos[1], pos[0]+size[0],pos[1]+size[1], pos[0],pos[1]+size[1] ) texcoords = (0.0,0.0, 1.0,0.0, 1.0,1.0, 0.0,1.0) draw(4, GL_QUADS, ('v2f', pos), ('t2f', texcoords)) pos2 = ( pos[0],pos[1]-size[1], pos[0]+size[0],pos[1]-size[1], pos[0]+size[0],pos[1]+size[1]-size[1], pos[0],pos[1]+size[1]-size[1] ) texcoords2 = (0.0,1.0, 1.0,1.0, 1.0,0.0, 0.0,0.0) color2 = (0,0,0,0.5, 0,0,0,0.5, 0.65,0.65,0.65,0.5, 0.65,0.65,0.65,0.5 ) draw(4, GL_QUADS, ('v2f', pos2), ('t2f', texcoords2), ('c4f', color2))
def draw(self): if self.window.debug and not self.hidden: gl.glColor4f(*self.color) graphics.draw(4, gl.GL_QUADS, ('v2f', self.rectangle)) if not self.fg_batch: for l in self.stat_labels_l: l.draw() for l in self.stat_labels_r: l.draw()
def drawCover(texture, pos=(0,0), size=(1.0,1.0)): with gx_texture(texture): pos = ( pos[0],pos[1], pos[0]+size[0],pos[1], pos[0]+size[0],pos[1]+size[1], pos[0],pos[1]+size[1] ) texcoords = (0.0,0.0, 1.0,0.0, 1.0,1.0, 0.0,1.0) draw(4, GL_QUADS, ('v2f', pos), ('t2f', texcoords)) set_color(1, 1, 1, 0.999, dfactor=GL_ONE_MINUS_SRC_COLOR) pos2 = ( pos[0],pos[1]-size[1], pos[0]+size[0],pos[1]-size[1], pos[0]+size[0],pos[1]+size[1]-size[1], pos[0],pos[1]+size[1]-size[1] ) texcoords2 = (0.0,1.0, 1.0,1.0, 1.0,0.0, 0.0,0.0) color2 = (0,0,0,0.5, 0,0,0,0.5, 0.65,0.65,0.65,0.5, 0.65,0.65,0.65,0.5 ) draw(4, GL_QUADS, ('v2f', pos2), ('t2f', texcoords2), ('c4f', color2))
def drawCover(texture, pos=(0,0), size=(1.0,1.0)): with gx_enable(GL_TEXTURE_2D): glBindTexture(GL_TEXTURE_2D,texture) pos = ( pos[0],pos[1], pos[0]+size[0],pos[1], pos[0]+size[0],pos[1]+size[1], pos[0],pos[1]+size[1] ) texcoords = (0.0,0.0, 1.0,0.0, 1.0,1.0, 0.0,1.0) draw(4, GL_QUADS, ('v2f', pos), ('t2f', texcoords)) pos2 = ( pos[0],pos[1]-size[1], pos[0]+size[0],pos[1]-size[1], pos[0]+size[0],pos[1]+size[1]-size[1], pos[0],pos[1]+size[1]-size[1] ) texcoords2 = (0.0,1.0, 1.0,1.0, 1.0,0.0, 0.0,0.0) color2 = (0,0,0,0.5, 0,0,0,0.5, 0.5,0.5,0.5,0.5, 0.5,0.5,0.5,0.5 ) draw(4, GL_QUADS, ('v2f', pos2), ('t2f', texcoords2), ('c4f', color2))
def on_draw(): main_window.clear() UI['batch_actors'].draw() UI['batch_map'].draw() graphics.draw(4, gl.GL_LINE_LOOP, ('v2i', [ UI['Field']['position'][0], UI['Field']['position'][1], UI['Field']['position'][0]+UI['Field']['size'][0], UI['Field']['position'][1], UI['Field']['position'][0]+UI['Field']['size'][0], UI['Field']['position'][1]+UI['Field']['size'][1], UI['Field']['position'][0], UI['Field']['position'][1]+UI['Field']['size'][1], ]))
def on_draw(self): vertex_data = cube_vertices(*self._data['position'], 1, 1) if self._show: glColor3f(1.0, 1.0, 1.0) else: glColor3f(0.64, 0.16, 0.16) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) glDisable(GL_CULL_FACE) graphics.draw(24, GL_QUADS, ('v3f/static', vertex_data)) glEnable(GL_CULL_FACE)
def on_draw(): glClear(GL_COLOR_BUFFER_BIT) draw( 3, GL_TRIANGLES, ('v2f', verts), ('c3B', colors), ) text.draw() clockDisplay.draw()
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) if self.turn_flag: self.leader_list = rl_loop.check_leader(self.auto_anim_x, self.human_anim_x) else: self.leader_list = [0 for i in range(5)] #print(leader_list) 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(self.obj_anim_x[obj]) for no, car in enumerate(self.human_cars): self.draw_car(self.human_anim_x[no], car.color) for no, car in enumerate(self.auto_cars): # if self.leader_list[no] == 1: # self.draw_car(self.auto_anim_x[no], 'purple') # else: self.draw_car(self.auto_anim_x[no], car.color) for no, car in enumerate(self.mock): if self.mock_anim_x[no][1] >= -0.8: self.draw_car(self.mock_anim_x[no], car.color) # for car in self.SEKIRO: # self.draw_car(car, 'yellow', opacity=50) # if self.heat is not None: # self.draw_heatmap() gl.glPopMatrix()
def draw_turn_bar(): # This just draws a thin bar at the top of the grid to show whose turn it is. if player == 1: color = P1_COLOR elif player == 2: color = P2_COLOR graphics.draw(4, gl.GL_POLYGON, ('v2i', (0, WIN_HEIGHT + TURN_BAR_HEIGHT, WIN_WIDTH, WIN_HEIGHT + TURN_BAR_HEIGHT, WIN_WIDTH, WIN_HEIGHT, 0, WIN_HEIGHT)), ('c4B', color * 4))
def show(self): pg.draw( 1, pyglet.gl.GL_POINTS, ( 'v2f', ( self.x, self.y # center dot )), ('c3B', (0, 0, 255)))
def draw(self): try: gl.glEnable(gl.GL_BLEND) gl.glColor4f(*self.color) graphics.draw(4, gl.GL_QUADS, ('v2f', self.rectangle)) gl.glDisable(gl.GL_BLEND) # self.label.draw() except AttributeError as e: self.window.logger.debug( "Bar is not ready to be drawn: {0}".format(e) )
def quad(width, height): draw(4, GL_QUADS, ('v2f', ( 0, 0, width, 0, width, height, 0, height, )), ('t2f', ( 0, 0, 1, 0, 1, 1, 0, 1, )), )
def on_draw(self, creatures, camera, win_width, win_height): glClear(GL_COLOR_BUFFER_BIT) camera.update_position() camera.focus(win_width, win_height) for creature in creatures: glPushMatrix() glTranslatef(creature.x, creature.y, 0) glRotatef(creature.angle * rad2deg, 0, 0, 1) if self.rendermode == RenderMode.BATCH: batch = creature.shape.get_batch() batch.draw() else: for primitive in creature.shape.primitives: if self.rendermode == RenderMode.VERTEXLIST: vertexlist = primitive.get_vertexlist() vertexlist.draw(primitive.primtype) elif self.rendermode == RenderMode.DRAW: flatverts = primitive.get_flat_verts() numverts = int(len(flatverts) / 2) draw( numverts, primitive.primtype, ('v2f/static', flatverts), ('c3B/static', primitive.color * numverts), ) elif self.rendermode == RenderMode.GLVERTEX: glColor3ub(*primitive.color) glBegin(primitive.primtype) for vert in primitive.verts: glVertex2f(*vert) glEnd() glPopMatrix() camera.hud_mode(win_width, win_height) clockDisplay.draw()
def on_draw(): '''The draw command is one glDraw command after gathering all of the vertex information from the simulation. The draw loop first draws the lines in simulation coordinates which is then "scaled" up using glMatrixmode.''' window.clear() vertices = [] colors = [] for p in liquid.particles: vertices.extend([p.x, p.y, p.x - p.u, p.y - p.v]) colors.extend(p.color) colors.extend([0, 0, 0]) graphics.draw( len(liquid.particles)*2, gl.GL_LINES, ('v2f', vertices), ('c3B', colors) ) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.glOrtho(0, liquid.width, liquid.height, 0, -1, 1) gl.glMatrixMode(gl.GL_MODELVIEW)
def draw(self): if self.settings["draw_mob_hp"]: gl.glColor4f(*lookup_color("red", gl=True)) gl.glLineWidth(3) for e in self.window.game.enemies: if e.hp < e.max_hp or self.settings["allways_draw_mob_hp"]: wpos = self.window.get_windowpos( e.x, e.y + e.sprite.height, check=True, tol=32, precise=True ) if wpos: width = (e.hp / e.max_hp) * e.sprite.width graphics.draw( 2, gl.GL_LINES, ( 'v2f', ( wpos[0] - width / 2, wpos[1], wpos[0] + width / 2, wpos[1]) ) ) # for b in self.buttons: # b.draw() self.bg_batch.draw() if self.window.game.player: for b in self.bars: b.draw() self.bar_fg_batch.draw() if self.stats: self.stats.draw() for b in self.progressbars: b.draw() self.fg_batch.draw() if self.target_label: self.target_label.draw()
def draw_heatmap(self): if not self.heatmap_show: return SIZE = (256, 256) if not self.heatmap_valid: o = self.center() x0 = o-np.asarray([1.5, 1.5])/self.magnify x0 = np.asarray([x0[0]-x0[0]%(1./self.magnify), x0[1]-x0[1]%(1./self.magnify)]) x1 = x0+np.asarray([4., 4.])/self.magnify x0 = o-np.asarray([1., 1.])/self.magnify x1 = o+np.asarray([1., 1.])/self.magnify self.heatmap_x0 = x0 self.heatmap_x1 = x1 vals = np.zeros(SIZE) for i, x in enumerate(np.linspace(x0[0], x1[0], SIZE[0])): for j, y in enumerate(np.linspace(x0[1], x1[1], SIZE[1])): vals[j, i] = self.heat(np.asarray([x, y])) vals = (vals-np.min(vals))/(np.max(vals)-np.min(vals)+1e-6) vals = self.cm(vals) vals[:,:,3] = 0.7 vals = (vals*255.99).astype('uint8').flatten() vals = (gl.GLubyte * vals.size) (*vals) img = pyglet.image.ImageData(SIZE[0], SIZE[1], 'RGBA', vals, pitch=SIZE[1]*4) self.heatmap = img.get_texture() self.heatmap_valid = True gl.glClearColor(1., 1., 1., 1.) gl.glEnable(self.heatmap.target) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glBindTexture(self.heatmap.target, self.heatmap.id) gl.glEnable(gl.GL_BLEND) x0 = self.heatmap_x0 x1 = self.heatmap_x1 graphics.draw(4, gl.GL_QUADS, ('v2f', (x0[0], x0[1], x1[0], x0[1], x1[0], x1[1], x0[0], x1[1])), ('t2f', (0., 0., 1., 0., 1., 1., 0., 1.)), #('t2f', (0., 0., SIZE[0], 0., SIZE[0], SIZE[1], 0., SIZE[1])) ) gl.glDisable(self.heatmap.target)
def drawOrientedRectangle(x, y, dir_x, dir_y, width, height, r, g, b, a): """Draw an oriented rectangle Args: x: A floating point indicating the rectangle's x position in window coordinate y: A floating point indicating the rectangle's y position in window coordinate dir_x: A floating point that represent the x coordinate of the vertor that give the direction relative to the rectangle's position of the side that have the height as length dir_y: A floating point that represent the y coordinate of the vertor that give the direction relative to the rectangle's position of the side that have the height as length width: A float indicating the rectangle's width height: A float indicating the rectangle's height r: An integer in the range [0, 255] that represent the rectangle's color's red component g: An integer in the range [0, 255] that represent the rectangle's color's green component b: An integer in the range [0, 255] that represent the rectangle's color's blue component a: An integer in the range [0, 255] that represent the rectangle's color's alpha component """ dir_length = sqrt(dir_x ** 2 + dir_y ** 2) dir_x = dir_x / dir_length dir_y = dir_y / dir_length draw(4, GL_TRIANGLE_STRIP, #Vertices of a rectangle in which the right side is diriged by dir ('v2f', (x, y, x + width * dir_y, y - width * dir_x, x + height * dir_x, y + height * dir_y, x + width * dir_y + height * dir_x, y + height * dir_y - width * dir_x)), ('c4B', ((r, g, b, a) * 4)))
def drawCover(texture, pos=(0, 0), size=(1.0, 1.0)): with gx_enable(GL_TEXTURE_2D): glBindTexture(GL_TEXTURE_2D, texture) # Draw First Cover pos = (pos[0], pos[1], pos[0] + size[0], pos[1], pos[0] + size[0], pos[1] + size[1], pos[0], pos[1] + size[1]) texcoords = (0.0, 0.0, 0.90, 0.0, 0.9, 0.9, 0.0, 0.9) draw(4, GL_QUADS, ("v2f", pos), ("t2f", texcoords)) # Draw Second Cover pos2 = ( pos[0], pos[1] - size[1], pos[0] + size[0], pos[1] - size[1], pos[0] + size[0], pos[1] + size[1] - size[1], pos[0], pos[1] + size[1] - size[1], ) texcoords2 = (0.0, 0.9, 0.9, 0.9, 0.9, 0.0, 0.0, 0.0) color2 = (0, 0, 0, 0, 0, 0, 0, 0, 0.4, 0.4, 0.4, 0, 0.4, 0.4, 0.4, 0) draw(4, GL_QUADS, ("v2f", pos2), ("t2f", texcoords2), ("c4f", color2))
def on_draw(): rule_plot_window.clear() for bar in rule_bars: graphics.glColor3f(0, 0, 255) graphics.draw(4, pyg.gl.GL_QUADS, ('v2f', bar)) graphics.glColor3f(0, 0, 0) graphics.glLineWidth(3) graphics.draw(2, pyg.gl.GL_LINES, ('v2f', (10.,30., 380., 30.))) graphics.draw(2, pyg.gl.GL_LINES, ('v2f',(10.,29., 10., 255)))
#!/usr/bin/python # $Id:$ from pyglet.gl import * from pyglet import graphics from pyglet import window win = window.Window() while not win.has_exit: win.dispatch_events() win.clear() graphics.draw(3, GL_TRIANGLES, ('v2f', [10., 10., 100., 10., 100., 100.]), ('c3B', [255, 0, 0, 0, 255, 0, 0, 0, 255])) win.flip()
def draw_line_loop(vertices): draw(len(vertices) / 2, GL_LINE_LOOP, ('v2f', vertices))
def draw_lines(vertices): draw(len(vertices) / 2, GL_LINES, ('v2f', vertices))
def draw_polygon(vertices): draw(len(vertices) / 2, GL_POLYGON, ('v2f', vertices)) draw_line_loop(vertices)
def draw(self): vertices = len(self.coords) / 2 draw(vertices, pyglet.gl.GL_POINTS, ('v2i', tuple(self.coords)))
def line(start, end): glEnable(GL_LINE_SMOOTH); #glLineWidth(2) draw(2, GL_LINES, ('v2i', map(int, start + end)))
def draw(self): self.sprite.draw() if configuration.DEBUG: glColor4f(1, 0, 0, 1) draw(4, GL_POINTS, ("v2i", self.rect.points))
def draw(self): gl.glColor3f(1, 0, 0) x, y, h, w = int(self.x), int(self.y), int(self.height), int(self.width) graphics.draw(4, gl.GL_LINE_LOOP, ('v2i', (x, y, x+w, y, x+w, y+h, x, y+h)))