def show_risk(self): # print('%s' % self.infos) # print("%s" % hasattr(self, 'reward_strategy')) if self.infos[0] != None and self.infos[0]['on_rect'] and hasattr(self, 'reward_strategy'): # win = self.env.viewers[0].window # win.switch_to() # win.dispatch_events() rect = self.infos[0]['last_rect'] rectx = sorted(list(set(map(lambda item: item[0], rect)))) # unique x recty = sorted(list(set(map(lambda item: item[1], rect)))) # unique y # gl.glViewport(0, 0, 96, 96) gl.glPointSize(3.3) gl.glBegin(gl.GL_POINTS) oc = [0.5, 0.5, 0.5] gl.glColor4f(*oc, 1.0) x = rectx[0] while x < rectx[1]: y = recty[0] while y < recty[1]: r = self.reward_strategy.risk(x, y) gl.glColor4f(r*oc[0], r*oc[1], r*oc[2], 1.0) print("%s = %s" % ((x, y), r)) gl.glVertex2f(x, y, 0) y += 1.0 x += 1.0 gl.glEnd()
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 set_radius(cls, value=10): if value < 5: value = 5 if value > 10: value = 10 glPointSize(value * 2) cls.radius = value
def _draw(self, shader=None, send_uniforms=True, *args, **kwargs): super(Mesh, self)._draw(*args, **kwargs) if not self.is_updated: self.update() self.is_updated = True if self.visible: # Bind the VAO and Texture, and draw. with self.texture as texture: # Change Material to Mesh's if send_uniforms: self.update_model_and_normal_matrix() self.uniforms.send_to(shader) texture.uniforms.send_to(shader) # Send Model and Normal Matrix to shader. try: shader.uniform_matrixf('model_matrix', self.model_matrix_global.T.ravel(), loc=self.modelmat_loc) shader.uniform_matrixf('normal_matrix', self.normal_matrix_global.T.ravel(), loc=self.normalmat_loc) except AttributeError: self.modelmat_loc = shader.get_uniform_location('model_matrix') self.normalmat_loc = shader.get_uniform_location('normal_matrix') pass # Set Point Size, if drawing a point cloud if self.drawstyle == 'point': gl.glPointSize(int(self.point_size)) # Send in the vertex and normal data self.data.draw(Mesh.drawstyle[self.drawstyle])
def _draw(self, shader=None, *args, **kwargs): super(Mesh, self)._draw(*args, **kwargs) self.update() if self.visible: # Change Material to Mesh's for uniform in self.uniforms: uniform.send_to(shader) # Send Model and Normal Matrix to shader. shader.uniform_matrixf('model_matrix', self.model_matrix_global.T.ravel()) shader.uniform_matrixf('normal_matrix', self.normal_matrix_global.T.ravel()) # Set Point Size, if drawing a point cloud if self.drawstyle == 'point': gl.glPointSize(int(self.point_size)) # Bind the VAO and Texture, and draw. with self.texture as texture: for uniform in self.texture.uniforms: uniform.send_to(shader) self.data.draw(Mesh.drawstyle[self.drawstyle])
def render(self): # draw scans gl.glColor3f(0, 0.2, 0.2) for scan in self.scans: vertices = [((scan.x + p.x) * 8 + 4, (scan.y + p.y) * 8 + 4) for p in self.scanner_model] vertices = tuple(item for sublist in vertices for item in sublist) pyglet.graphics.draw(int(len(vertices) / 2), pyglet.gl.GL_LINES, ('v2f', vertices)) # draw ships for ship in self.ships: ship.sprite.position = ship.position * 8 + Vec2d(4, 4) ship.sprite.draw() gl.glColor3f(1, 1, 0) # draw explosions for explosion in self.explosions: gl.glPointSize(8.0) pyglet.graphics.draw(1, pyglet.gl.GL_POINTS, ('v2i', (explosion.x * 8 + 4, explosion.y * 8 + 4))) # draw laser lines for shot in self.shots: lasers = continuous_laser(shot.owner.position, shot.position) vertices = [(p.x * 8 + 4, p.y * 8 + 4) for p in lasers] vertices = tuple(item for sublist in vertices for item in sublist) gl.glColor3f(1, 0, 0) pyglet.graphics.draw(int(len(vertices) / 2), pyglet.gl.GL_LINE_LOOP, ('v2i', vertices))
def draw_message(self): if event.message != self.current_message: self.current_message = event.message self.message_label.text = event.message self.message_label.font_size = event.message_size xa = self.message_label.content_width // 2 + 20 ya = self.message_label.content_height // 2 + 5 gl.glLineWidth(3.0) gl.glPointSize(1.0) draw.set_color(0, 0, 0, 0.8) draw.rect( self.message_label.x - xa, self.message_label.y - ya, self.message_label.x + xa, self.message_label.y + ya ) draw.set_color(0, 0, 0, 1) draw.rect_outline( self.message_label.x - xa, self.message_label.y - ya, self.message_label.x + xa, self.message_label.y + ya ) draw.points( ( self.message_label.x - xa, self.message_label.y - ya, self.message_label.x + xa, self.message_label.y - ya, self.message_label.x + xa, self.message_label.y + ya, self.message_label.x - xa, self.message_label.y + ya, ) ) self.message_label.draw()
def render(self): # for smooth rendering # draw ships for ship in self.ships: ship.sprite.position = ship.position * 8 + Vec2d(4, 4) ship.sprite.draw() gl.glColor3f(1, 1, 0) # draw explosions TODO: Animate! for explosion in self.explosions: gl.glPointSize(8.0) pyglet.graphics.draw( 1, pyglet.gl.GL_POINTS, ('v2i', (explosion.x * 8 + 4, explosion.y * 8 + 4)) ) laser_points = [] # draw laser lines for shot in self.shots: startpos = shot.owner.position * 8 + Vec2d(4, 4) laser_points.append(startpos.x) laser_points.append(startpos.y) laser_points.append(shot.position.x * 8 + 4) laser_points.append(shot.position.y * 8 + 4) gl.glColor3f(1, 0, 0) pyglet.graphics.draw( len(self.shots) * 2, pyglet.gl.GL_LINES, ('v2i', laser_points) )
def on_draw(self): gl.glClearColor(0, 0.0, 0.0, 1.) self.clear() width, height = self.get_size() gl.glViewport(0, 0, width, height) K_gl = get_projector_gl_intrinsics() TF = get_extrinsics() R = np.array([[-1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., -1., 0.], [0., 0., 0., 1.]]) full_mat = np.ascontiguousarray((K_gl.dot(TF.dot(R))).astype('f4')) with self.prog.using(): self.prog.uniforms.Mvp = full_mat.tolist() gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glPointSize(25.) distance = (0, 0, 1) gl.glPointParameterfv(gl.GL_POINT_DISTANCE_ATTENUATION, (gl.GLfloat * 3)(*distance)) gl.glEnable(gl.GL_POINT_SPRITE) self.vertex_info.draw(gl.GL_POINTS) 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) gl.glDisable(gl.GL_BLEND) self.fps_display.draw()
def _gl_enable_smooth_lines(): # make the lines from Path3D objects less ugly gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) # set the width of lines to 4 pixels gl.glLineWidth(4) # set PointCloud markers to 4 pixels in size gl.glPointSize(4)
def render_additional_points(self, pts): if pts == None: return gl.glPointSize(5) gl.glBegin(gl.GL_POINTS) for (x, y) in pts: gl.glColor4f(0, 0, 1.0, 1.0) gl.glVertex2f(x, y, 0) gl.glEnd()
def gl_enable_smooth_lines(): gl.glEnable(gl.GL_LINE_SMOOTH) # make the lines from Path3D objects less ugly gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(0.5) # set the width of lines to 2 pixels gl.glPointSize(12) # set PointCloud markers to 8 pixels in size gl.glEnable(gl.GL_PROGRAM_POINT_SIZE) # set gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_BLEND)
def initializeGL(self): gl.glClearColor(0, 0, 0, 0) gl.glPointSize(10.0) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
def render1(self): gl.glPointSize(2.0) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glBegin(gl.GL_POINTS) # draw point for p in self.v: #print( ' p: ', p ) gl.glVertex3f(p[0], p[1], 0) gl.glEnd() gl.glDisable(gl.GL_POINT_SMOOTH)
def draw_point(pos, color=(1, 0, 0, 1), size=5): gl.glColor4f(*color) gl.glPointSize(size) gl.glBegin(gl.GL_POINTS) gl.glVertex2f(*pos) gl.glEnd() # -- reset color gl.glColor4f(1, 1, 1, 1)
def renderCatalog(cat, far): gl.glDisable(gl.GL_LIGHTING) for s in cat: c = s.getRgb() gl.glPointSize(s.getSize()) gl.glBegin(gl.GL_POINTS) gl.glColor3f(c[0], c[1], c[2]) gl.glVertex3f(far * cos(s.ra_rad) * cos(s.dec_rad), far * sin(s.ra_rad) * cos(s.dec_rad), far * sin(s.dec_rad)) gl.glEnd() gl.glEnable(gl.GL_LIGHTING)
def _generic_draw_line_strip(point_list: PointList, color: Color, line_width: float=1, mode: int=moderngl.LINE_STRIP): """ Draw a line strip. A line strip is a set of continuously connected line segments. Args: :point_list: List of points making up the line. Each point is in a list. So it is a list of lists. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :border_width: Width of the line in pixels. Returns: None Raises: None """ program = shader.program( vertex_shader=line_vertex_shader, fragment_shader=line_fragment_shader, ) buffer_type = np.dtype([('vertex', '2f4'), ('color', '4B')]) data = np.zeros(len(point_list), dtype=buffer_type) data['vertex'] = point_list color = get_four_byte_color(color) data['color'] = color vbo = shader.buffer(data.tobytes()) vbo_desc = shader.BufferDescription( vbo, '2f 4B', ('in_vert', 'in_color'), normalized=['in_color'] ) vao_content = [vbo_desc] vao = shader.vertex_array(program, vao_content) with vao: program['Projection'] = get_projection().flatten() gl.glLineWidth(line_width) gl.glPointSize(line_width) 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) vao.render(mode=mode)
def draw_point(point): """ Draw a point :param point: Coordinates of the point """ from pyglet import gl gl.glPointSize(7) gl.glBegin(gl.GL_POINTS) gl.glColor3f(0, 0, 1) gl.glVertex3f(point[0], 0.1, point[2]) gl.glEnd()
def init_gl(self): """ Perform the magic incantations to create an OpenGL scene. """ # the background color gl.glClearColor(.97, .97, .97, 1.0) max_depth = (np.abs(self.scene.bounds).max(axis=1)**2).sum()**.5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) # put the light at one corner of the scenes AABB gl.glLightfv( gl.GL_LIGHT0, gl.GL_POSITION, rendering.vector_to_gl(np.append(self.scene.bounds[1], 0))) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, rendering.vector_to_gl(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, rendering.vector_to_gl(1, 1, 1, .75)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, rendering.vector_to_gl(.1, .1, .1, .2)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, rendering.vector_to_gl(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, rendering.vector_to_gl(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, rendering.vector_to_gl(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) 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.glLineWidth(1.5) gl.glPointSize(4)
def draw(self): """Render the particle system.""" if not self.live_particles: return if self.dirty_indices: indices = [p.slot for p in self.live_particles if not p.dead] self.indices = (gl.GLuint * len(indices))(*indices) self.dirty_indices = False gl.glPointSize(self.particle_class.size) gl.glInterleavedArrays(gl.GL_C4F_N3F_V3F, 0, self.data) gl.glDrawElements(gl.GL_POINTS, len(self.indices), gl.GL_UNSIGNED_INT, self.indices)
def draw(self): p = adjust_for_cam(self._body.position) gl.glEnable(pyglet.gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, BLASTER_IMAGE.id) gl.glEnable(gl.GL_POINT_SPRITE) gl.glTexEnvi(gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE) gl.glPointSize(4 * SPACE.scale) gl.glBegin(gl.GL_POINTS) # TODO: more optimized to draw as one large batch gl.glVertex3f(p.x, p.y, 0) gl.glEnd();
def update_all(self): """ 在绘制之前,针对形变进行计算,通过设置openGL的属性来达到绘制出变形的图形 """ self.update_points() self.update_vertex_list() self.update_anchor() gl.glLoadIdentity() # reset gl gl.glLineWidth(self.line_width) gl.glPointSize(self.point_size) self.transform.update_gl() # handle shapes click envets all_shapes.discard(self) all_shapes.add(self)
def draw_ai_message(self): if event.ai_message != self.current_ai_message: self.current_ai_message = event.ai_message self.ai_message_label.text = event.ai_message w = self.ai_message_label.content_width mx = self.ai_message_label.x my = self.ai_message_label.y gl.glLineWidth(3.0) gl.glPointSize(1.0) draw.set_color(0, 0, 0, 0.8) draw.rect(mx - 80, 10, mx + w + 10, 100) self.ai_message_label.draw() draw.set_color(1, 1, 1, 1) if event.ai_head != None: event.ai_head.blit(mx - 80, 17)
def draw(self): glPushMatrix() glPushAttrib(GL_STENCIL_BUFFER_BIT) glClear(GL_STENCIL_BUFFER_BIT) glTranslatef(self.parent.x, self.parent.y, 0) glDisable(GL_TEXTURE_2D) loader = self.loader if loader.shape == LINE_SHAPE: glEnable(GL_LINE_SMOOTH) glEnable(GL_POINT_SMOOTH) glLineWidth(loader.borderSize) glPointSize(loader.borderSize) self.vertex.draw(GL_LINES) self.vertex.draw(GL_POINTS) elif loader.shape == RECTANGLE_SHAPE: width = self.parent.width height = self.parent.height if loader.fillType != NONE_FILL: # for counters if self.counter_stencil: glEnable(GL_STENCIL_TEST) glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE) glStencilFunc(GL_ALWAYS, 1, 1) glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE) self.counter_stencil.draw(GL_QUADS) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glStencilFunc(GL_EQUAL, 1, 1) self.draw_rectangle() glDisable(GL_STENCIL_TEST) else: self.draw_rectangle() if self.border is not None: self.border.draw(GL_QUADS) elif loader.shape == ELLIPSE_SHAPE: if loader.fillType != NONE_FILL: glEnable(GL_STENCIL_TEST) glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE) glStencilFunc(GL_ALWAYS, 1, 1) glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE) self.stencil.draw(GL_TRIANGLES) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glStencilFunc(GL_EQUAL, 1, 1) self.draw_rectangle(True) glDisable(GL_STENCIL_TEST) if self.border: self.border.draw(GL_QUADS) glPopAttrib() glPopMatrix()
def draw(self): gl.glLoadIdentity() gl.glTranslatef(self.x, self.y, self.z) # rotation gl.glRotatef(self.rx - 40, 1, 0, 0) gl.glRotatef(self.ry, 0, 1, 0) gl.glRotatef(self.rz - 40, 0, 0, 1) # color gl.glColor3f(*gray) gl.glPointSize(self.pointsize) pyglet.graphics.draw( len(self.points), gl.GL_POINTS, #v3f/stream c4B/static ('v3f', self.points.reshape(-1)), ('c3f', self.data_points_color.reshape(-1)))
def bezier_draw_points_curve(cps, n=10, red=False): from pyglet import gl pts = [bezier_point(cps, i / (n - 1)) for i in range(0, n)] gl.glPointSize(5) gl.glBegin(gl.GL_POINTS) if red: gl.glColor3f(0, 0, 1) else: gl.glColor3f(1, 0, 0) for i, p in enumerate(pts): gl.glVertex3f(p[0], 0.01, p[2]) gl.glEnd() gl.glColor3f(1, 1, 1)
def init_gl(self, on_init=None, **kwargs): gl.glClearColor(.97, .97, .97, 1.0) max_depth = (np.abs(self.scene.bounds).max(axis=1)**2).sum()**.5 max_depth = np.clip(max_depth, 500.00, np.inf) gl.glDepthRange(0.0, max_depth) gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) # put the light at one corner of the scenes AABB gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, _gl_vector(np.append(self.scene.bounds[1], 0))) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, _gl_vector(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, _gl_vector(1, 1, 1, .75)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_AMBIENT, _gl_vector(.1, .1, .1, .2)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, _gl_vector(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, _gl_vector(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, _gl_vector(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) 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.glLineWidth(1.5) gl.glPointSize(4) if on_init: on_init(gl, **kwargs)
def draw_points(point_list, color, size): """ Draw a set of points. Args: :point_list: List of points Each point is in a list. So it is a list of lists. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :size: Size of the point in pixels. Returns: None Raises: None Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> point_list = ((165, 495), \ (165, 480), \ (165, 465), \ (195, 495), \ (195, 480), \ (195, 465)) >>> arcade.draw_points(point_list, arcade.color.ZAFFRE, 10) >>> 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.glLoadIdentity() GL.glPointSize(size) 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_POINTS) for point in point_list: GL.glVertex3f(point[0], point[1], 0.5) GL.glEnd()
def polygon(vertices: List[Vector], theme=Theme()): # batch = pyglet.graphics.Batch() n_vertices = len(vertices) vertices = vectors2vertices(vertices) if theme.fill: gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL) pyglet.graphics.draw(n_vertices, gl.GL_POLYGON, ('v2f', vertices), ('c4f', n_vertices * theme.fill.normalized)) if theme.stroke: gl.glLineWidth(float(theme.stroke_weight)) gl.glPolygonMode(gl.GL_FRONT, gl.GL_LINE) pyglet.graphics.draw(n_vertices, gl.GL_POLYGON, ('v2f', vertices), ('c4f', n_vertices * theme.stroke.normalized)) gl.glPolygonMode(gl.GL_FRONT, gl.GL_POINT) gl.glPointSize(float(theme.stroke_weight)) pyglet.graphics.draw(n_vertices, gl.GL_POLYGON, ('v2f', vertices), ('c4f', n_vertices * theme.stroke.normalized))
def init_gl(self): gl.glClearColor(.93, .93, 1, 1) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1) gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, _gl_vector(.5, .5, 1, 0)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPECULAR, _gl_vector(.5, .5, 1, 1)) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, _gl_vector(1, 1, 1, 1)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, _gl_vector(1, 0, .5, 0)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, _gl_vector(.5, .5, .5, 1)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, _gl_vector(1, 1, 1, 1)) gl.glColorMaterial(gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT, _gl_vector(0.192250, 0.192250, 0.192250)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, _gl_vector(0.507540, 0.507540, 0.507540)) gl.glMaterialfv(gl.GL_FRONT, gl.GL_SPECULAR, _gl_vector(.5082730, .5082730, .5082730)) gl.glMaterialf(gl.GL_FRONT, gl.GL_SHININESS, .4 * 128.0) 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.glLineWidth(1.5) gl.glPointSize(4)
def test_closest_point_in_segment(): import pyglet import draw_util from pyglet import gl w = pyglet.window.Window() line = [] point = vec2(0, 0) @w.event def on_mouse_press(x, y, button, modifiers): if len(line) < 2: line.append(vec2(x, y)) else: point.x = x point.y = y @w.event def on_draw(): w.clear() gl.glBegin(gl.GL_POINTS) for ep in line: gl.glVertex2f(*ep) gl.glEnd() if len(line) == 2: gl.glBegin(gl.GL_LINES) gl.glVertex2f(*line[0]) gl.glVertex2f(*line[1]) gl.glEnd() if not (point.x == point.y == 0): closest = closest_point_in_segment(point, *line) gl.glBegin(gl.GL_POINTS) gl.glVertex2f(*closest) gl.glEnd() radius = (closest - point).length() draw_util.draw_circumference(point.x, point.y, radius) gl.glPointSize(4) pyglet.app.run()
def render(self): # for smooth rendering # draw ships for ship in self.ships: ship.sprite.position = ship.position * 8 + Vec2d(4, 4) ship.sprite.draw() gl.glColor3f(1, 1, 0) # draw explosions TODO: Animate! for explosion in self.explosions: gl.glPointSize(8.0) pyglet.graphics.draw(1, pyglet.gl.GL_POINTS, ("v2i", (explosion.x * 8 + 4, explosion.y * 8 + 4))) laser_points = [] # draw laser lines for shot in self.shots: startpos = shot.owner.position * 8 + Vec2d(4, 4) laser_points.append(startpos.x) laser_points.append(startpos.y) laser_points.append(shot.position.x * 8 + 4) laser_points.append(shot.position.y * 8 + 4) gl.glColor3f(1, 0, 0) pyglet.graphics.draw(len(self.shots) * 2, pyglet.gl.GL_LINES, ("v2i", laser_points))
def set_state(self): gl.glPushAttrib( gl.GL_ENABLE_BIT ) gl.glBindTexture( gl.GL_TEXTURE_2D, self.texture.id ) gl.glEnable( gl.GL_POINT_SPRITE ) gl.glDisable( gl.GL_LIGHTING ) if self.attenuate: quadratic = (gl.GLfloat * 3)() quadratic[:] = (1.0, 0.0, 0.01) gl.glPointParameterfv( gl.GL_POINT_DISTANCE_ATTENUATION, quadratic ) max_size = gl.GLfloat() gl.glGetFloatv( gl.GL_POINT_SIZE_MAX, max_size ) gl.glPointParameterf( gl.GL_POINT_FADE_THRESHOLD_SIZE, 60.0 ) gl.glPointParameterf( gl.GL_POINT_SIZE_MIN, 1.0 ) gl.glPointParameterf( gl.GL_POINT_SIZE_MAX, max_size ) gl.glTexEnvf( gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE ) gl.glPointSize( self.point_size )
def draw(self): if not self.vao: self.vao = VAO(indices=self.array_indices) self._fill_vao() if self.visible: if self.dynamic: for vbo in self.vbos: vbo._buffer_subdata() if self.drawmode == gl.GL_POINTS: gl.glPointSize(self.point_size) for texture in self.textures: texture.bind() with self.vao as vao: self.uniforms.send() vao.draw(mode=self.drawmode) for texture in self.textures: texture.unbind()
def draw_point(x, y, color, size): """ Draw a point. Args: :x: x position of point. :y: y position of point. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :size: Size of the point in pixels. 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_point(60, 495, arcade.color.RED, 10) >>> 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.glLoadIdentity() GL.glPointSize(size) 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_POINTS) GL.glVertex3f(x, y, 0.5) GL.glEnd()
def render(self): # draw scans gl.glColor3f(0, 0.2, 0.2) for scan in self.scans: vertices = [ ((scan.x + p.x) * 8 + 4, (scan.y + p.y) * 8 + 4) for p in self.scanner_model ] vertices = tuple(item for sublist in vertices for item in sublist) pyglet.graphics.draw( int(len(vertices) / 2), pyglet.gl.GL_LINES, ('v2f', vertices) ) # draw ships for ship in self.ships: ship.sprite.position = ship.position * 8 + Vec2d(4, 4) ship.sprite.draw() gl.glColor3f(1, 1, 0) # draw explosions for explosion in self.explosions: gl.glPointSize(8.0) pyglet.graphics.draw( 1, pyglet.gl.GL_POINTS, ('v2i', (explosion.x * 8 + 4, explosion.y * 8 + 4)) ) # draw laser lines for shot in self.shots: lasers = continuous_laser(shot.owner.position, shot.position) vertices = [ (p.x * 8 + 4, p.y * 8 + 4) for p in lasers ] vertices = tuple(item for sublist in vertices for item in sublist) gl.glColor3f(1, 0, 0) pyglet.graphics.draw( int(len(vertices) / 2), pyglet.gl.GL_LINE_LOOP, ('v2i', vertices) )
def draw(self): """ Draw the Mesh if it's visible, from the perspective of the camera and lit by the light. The function sends the uniforms""" if not self.vao: self.vao = VAO(indices=self.array_indices) self._fill_vao() if self.visible: if self.dynamic: for vbo in self.vbos: vbo._buffer_subdata() if self.drawmode == gl.GL_POINTS: gl.glPointSize(self.point_size) for texture in self.textures: texture.bind() with self.vao as vao: self.uniforms.send() vao.draw(mode=self.drawmode) for texture in self.textures: texture.unbind()
def drawpoint( pt ): 'draw a single point with white outline and black interior' gl.glPointSize( 6 ) gl.glBegin( gl.GL_POINTS ) gl.glColor3f( 1, 1, 1) gl.glVertex3d( pt[0], pt[1], pt[2] ) gl.glEnd() gl.glPointSize( 4 ) gl.glBegin( gl.GL_POINTS ) gl.glColor3f( 0, 0, 0) gl.glVertex3d( pt[0], pt[1], pt[2] ) gl.glEnd() gl.glPointSize( 3 )
def _draw(self): gl.glLineWidth(self._line_width) gl.glPointSize(self._point_size) gl.glColor4f(*self._gl_colour) self._vertex_list.draw(self._gl_line_type)
def training_status(self, mode='human'): if self.viewer is None: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(WINDOW_W, WINDOW_H) self.transform = rendering.Transform() if "t" not in self.__dict__: return # reset() not called yet zoom = ZOOM*SCALE #0.1*SCALE*max(1-self.t, 0) + ZOOM*SCALE*min(self.t, 1) # Animate zoom first second zoom_state = ZOOM*SCALE*STATE_W/WINDOW_W zoom_video = ZOOM*SCALE*VIDEO_W/WINDOW_W scroll_x = 0 #self.car.hull.position[0] #0 scroll_y = 0 #self.car.hull.position[1] #-30 angle = 0 #-self.car.hull.angle #0 vel = 0 #self.car.hull.linearVelocity #0 self.transform.set_scale(zoom, zoom) self.transform.set_translation(WINDOW_W/2, WINDOW_H/2) # self.transform.set_translation( # WINDOW_W/2 - (scroll_x*zoom*math.cos(angle) - scroll_y*zoom*math.sin(angle)), # WINDOW_H/4 - (scroll_x*zoom*math.sin(angle) + scroll_y*zoom*math.cos(angle)) ) # self.transform.set_rotation(angle) arr = None win = self.viewer.window if mode != 'state_pixels' and mode != 'rgb_array': win.switch_to() win.dispatch_events() if mode=="rgb_array" or mode=="state_pixels": win.clear() t = self.transform self.transform.set_translation(0, 0) self.transform.set_scale(0.0167, 0.0167) if mode=='rgb_array': VP_W = VIDEO_W VP_H = VIDEO_H else: VP_W = WINDOW_W//2 #STATE_W VP_H = WINDOW_H//2 #STATE_H gl.glViewport(0, 0, VP_W, VP_H) t.enable() self.render_road() for geom in self.viewer.onetime_geoms: geom.render() t.disable() # self.render_indicators(WINDOW_W, WINDOW_H) # TODO: find why 2x needed, wtf image_data = pyglet.image.get_buffer_manager().get_color_buffer().get_image_data() arr = np.fromstring(image_data.data, dtype=np.uint8, sep='') arr = arr.reshape(VP_H, VP_W, 4) arr = arr[::-1, :, 0:3] if mode=="rgb_array" and not self.human_render: # agent can call or not call env.render() itself when recording video. win.flip() if mode=='human': self.human_render = True win.clear() t = self.transform gl.glViewport(0, 0, WINDOW_W, WINDOW_H) t.enable() self.render_road() for geom in self.viewer.onetime_geoms: geom.render() with open("training_positions.csv", 'r') as fin: line_number = sum(1 for _ in fin) with open("training_positions.csv", 'r') as fin: gl.glPointSize(10) for i, line in enumerate(fin): epoch, angle, coord_x, coord_y = list(map(float, line.strip().split(","))) new_coord = (angle, coord_x, coord_y) gl.glBegin(gl.GL_POINTS) alpha = (i+1)/line_number gl.glColor4f(alpha, 0, 1-alpha, 0.8) gl.glVertex3f(coord_x, coord_y, 0) gl.glEnd() t.disable() # self.render_indicators(WINDOW_W, WINDOW_H) win.flip() # # Drawing a rock: # gl.glBegin(gl.GL_QUADS) # gl.glColor4f(0,0,0,1) # gl.glVertex3f(10, 30, 0) # gl.glVertex3f(10, 10, 0) # gl.glVertex3f(30, 10, 0) # gl.glVertex3f(30, 30, 0) # gl.glEnd() self.viewer.onetime_geoms = [] return arr
def render_road(self): gl.glBegin(gl.GL_QUADS) gl.glColor4f(0.4, 0.8, 0.4, 1.0) gl.glVertex3f(-PLAYFIELD, +PLAYFIELD, 0) gl.glVertex3f(+PLAYFIELD, +PLAYFIELD, 0) gl.glVertex3f(+PLAYFIELD, -PLAYFIELD, 0) gl.glVertex3f(-PLAYFIELD, -PLAYFIELD, 0) gl.glColor4f(0.4, 0.9, 0.4, 1.0) k = PLAYFIELD / 20.0 for x in range(-20, 20, 2): for y in range(-20, 20, 2): gl.glVertex3f(k * x + k, k * y + 0, 0) gl.glVertex3f(k * x + 0, k * y + 0, 0) gl.glVertex3f(k * x + 0, k * y + k, 0) gl.glVertex3f(k * x + k, k * y + k, 0) for poly, color in self.road_poly: gl.glColor4f(color[0], color[1], color[2], 1) for p in poly: gl.glVertex3f(p[0], p[1], 0) gl.glEnd() ##################################### if DEBUG_DRAWING: # Draw control points gl.glPointSize(7.0) gl.glBegin(gl.GL_POINTS) gl.glColor4f(1, 0, 1, 1) for i in range(self.next_road_tile, self.next_road_tile + LOOK_AHEAD): a, b, x, y = self.track[i % len(self.track)] gl.glVertex3f(x, y, 0.9) gl.glEnd() # Draw angles gl.glLineWidth(3.0) gl.glColor4f(0, 1, 0, 1) for i in range(self.next_road_tile, self.next_road_tile + LOOK_AHEAD): a, b, x, y = self.track[i % len(self.track)] gl.glBegin(gl.GL_LINES) gl.glVertex3f(x, y, 0.9) line_len = 1 rot = math.pi / 2 gl.glVertex3f(x + line_len * math.cos(b + rot), y + line_len * math.sin(b + rot), 0.9) gl.glEnd() # Interpolation debug gl.glBegin(gl.GL_POINTS) gl.glColor4f(1, 1, 1, 1) tip = np.array( (self.car.wheels[0].position + self.car.wheels[1].position) / 2) gl.glVertex3f(*tip, 0.5) gl.glColor4f(1, 0, 0, 1) gl.glVertex3f(*self.ctrl_pts[self.next_road_tile - 1], 1) gl.glColor4f(1, 0, 0, 1) gl.glVertex3f(*self.ctrl_pts[self.next_road_tile - 2], 1) gl.glEnd() p1 = self.ctrl_pts[self.next_road_tile - 1] p2 = self.ctrl_pts[self.next_road_tile - 2] u = (p1 - p2) / TRACK_DETAIL_STEP v = (tip - p2) / TRACK_DETAIL_STEP interp = np.dot(v, u) new_ctrl = np.transpose([ np.interp(self.indices + interp, self.indices, self.ctrl_pts[:, 0]), np.interp(self.indices + interp, self.indices, self.ctrl_pts[:, 1]), ]) gl.glBegin(gl.GL_POINTS) gl.glColor4f(0, 1, 1, 1) for i in range(self.next_road_tile, self.next_road_tile + LOOK_AHEAD): gl.glVertex3f(*new_ctrl[i % len(self.ctrl_pts)], 0.9) gl.glEnd()
def draw(self): gl.glPointSize(5.0) gl.glCallList(self.list) gl.glColor3f(1.0, 1.0, 1.0)
def draw(self): gl.glLineWidth(1.5) phys_comp_list = self.manager.comps[phys.PhysicsEcsComponent.name()] grav_comp_list = self.manager.comps[phys.GravityEcsComponent.name()] coll_comp_list = self.manager.comps[coll.CollisionEcsComponent.name()] planet_comp_list = self.manager.comps[planet.PlanetEcsComponent.name()] ship_comp_list = self.manager.comps[ship.ShipEcsComponent.name()] base_comp_list = self.manager.comps[base.BaseEcsComponent.name()] aster_comp_list = self.manager.comps[asteroid.AsteroidEcsComponent.name()] rend_plan_comp_list = self.manager.comps[planet.RenderPlanetEcsComponent.name()] rend_ship_comp_list = self.manager.comps[ship.RenderShipEcsComponent.name()] rend_base_comp_list = self.manager.comps[base.RenderBaseEcsComponent.name()] rend_aster_comp_list = self.manager.comps[asteroid.RenderAsteroidEcsComponent.name()] rend_anim_comp_list = self.manager.comps[RenderAnimationEcsComponent.name()] entities = self.manager.entities player_alive = False if self.player_entity_id in entities: player_alive = True ppc = self.manager.get_entity_comp(self.player_entity_id, phys.PhysicsEcsComponent.name()) psc = self.manager.get_entity_comp(self.player_entity_id, ship.ShipEcsComponent.name()) if ppc: self.tx = ppc.pos.x - const.WIDTH / 2 self.ty = ppc.pos.y - const.HEIGHT / 2 tx = self.tx ty = self.ty area = (tx, ty, const.WIDTH, const.HEIGHT) #img.get(img.IMG_BG).blit(0, 0) gl.glPointSize( 1 ); self.starfield.draw(tx, ty) gl.glPushMatrix() gl.glLoadIdentity() gl.glTranslatef(-tx, -ty, 0.0) # predraw (lines, areas etc) for idx, eid in enumerate(entities): basec = base_comp_list[idx] physc = phys_comp_list[idx] if basec: rbc = rend_base_comp_list[idx] if basec.crew_load > 0: draw_circle(physc.pos.x, physc.pos.y, basec.radius, None, gl.GL_LINES, (1, 0, 0, 1)) for idx, eid in enumerate(entities): shipc = ship_comp_list[idx] basec = base_comp_list[idx] asterc = aster_comp_list[idx] planetc = planet_comp_list[idx] physc = phys_comp_list[idx] collc = coll_comp_list[idx] if not physc: continue #if eid == self.player_entity_id: # print physc.pos.x, physc.pos.y, collc.radius, tx, tx # print circle_rect_intersect(physc.pos.x, physc.pos.y, collc.radius, tx, tx, const.WIDTH, const.HEIGHT) #clipping if not circle_rect_intersect(physc.pos.x, physc.pos.y, collc.radius, tx, ty, const.WIDTH, const.HEIGHT): continue if shipc: rsc = rend_ship_comp_list[idx] rsc.process() ship_sprite = rsc.spr ship_sprite.x = physc.pos.x ship_sprite.y = physc.pos.y ship_sprite.rotation = -shipc.rotation ship_sprite.draw() if rsc.thrust_cooldown: thrust_sprite = rsc.thrust_spr thrust_sprite.x = physc.pos.x thrust_sprite.y = physc.pos.y thrust_sprite.rotation = -shipc.rotation thrust_sprite.draw() #draw_circle(physc.pos.x, physc.pos.y, collc.radius, None, gl.GL_POLYGON, (1, 1, 0, 1)) #dir_radians = math.radians(shipc.rotation) #dirv = vec2d.vec2d(math.cos(dir_radians), math.sin(dir_radians)) #dirv.length = collc.radius #gl.glColor3f(1, 0, 0, 1) #gl.glBegin(gl.GL_LINES) #gl.glVertex2f(physc.pos.x, physc.pos.y) #gl.glVertex2f(physc.pos.x + dirv.x, physc.pos.y + dirv.y) #gl.glEnd() elif basec: rbc = rend_base_comp_list[idx] base_sprite = rbc.spr if base_sprite: base_sprite.x = physc.pos.x base_sprite.y = physc.pos.y base_sprite.draw() else: draw_circle(physc.pos.x, physc.pos.y, collc.radius, None, gl.GL_POLYGON, (1, 0, 0, 1)) elif asterc: rac = rend_aster_comp_list[idx] aster_sprite = rac.spr if aster_sprite: aster_sprite.x = physc.pos.x aster_sprite.y = physc.pos.y aster_sprite.draw() else: draw_circle(physc.pos.x, physc.pos.y, collc.radius, None, gl.GL_POLYGON, (0, 1, 0, 1)) elif planetc: rpc = rend_plan_comp_list[idx] planet_sprite = rpc.spr if planet_sprite: planet_sprite.x = physc.pos.x planet_sprite.y = physc.pos.y planet_sprite.draw() else: draw_circle(physc.pos.x, physc.pos.y, collc.radius) if planetc.pname: label = pyglet.text.Label(planetc.pname, font_name=font.FONT_MONO.name, font_size=12, x=physc.pos.x, y=physc.pos.y, # + collc.radius + 5 anchor_x='center', anchor_y='center', color=(0, 0, 255, 255)) label.draw() #gc = grav_comp_list[idx] #if gc and gc.gravity_radius: # draw_circle(physc.pos.x, physc.pos.y, gc.gravity_radius, None, gl.GL_LINE_LOOP) for anim in rend_anim_comp_list: if not anim: continue #print 'we have an anim to show!' a = anim.anim a.draw() if player_alive and not self.manager.victory: for idx, eid in enumerate(entities): shipc = ship_comp_list[idx] if shipc: if shipc.messages: pos_mod = 0.0 for message in shipc.messages: label = message[5] if not label: label = pyglet.text.Label(message[0], font_name=font.FONT_MONO.name, font_size=12, x = message[2], y = message[3] + pos_mod, anchor_x='left', anchor_y='bottom', color=message[4]) message[5] = label label.draw() pos_mod += 25 gl.glPopMatrix() # interface if player_alive and not self.manager.victory: if self.manager._navigation: gl.glLineWidth(1) nav_circle_radius = (const.HEIGHT - 100) // 2 draw_circle(const.WIDTH // 2, const.HEIGHT // 2, nav_circle_radius, None, gl.GL_LINE_LOOP, (1, 1, 0, 0.4)) for idx, eid in enumerate(entities): basec = base_comp_list[idx] physc = phys_comp_list[idx] if not physc: continue distance = ppc.pos.get_distance(physc.pos) / 50 if distance > 3 and distance < nav_circle_radius: gl.glEnable(gl.GL_BLEND) gl.glColor4f(1, 1, 0, 0.4) if basec and basec.crew_load > 0: cpo = get_circle_closest_point(physc.pos, ppc.pos, nav_circle_radius) cpi = get_circle_closest_point(physc.pos, ppc.pos, nav_circle_radius - distance) gl.glBegin(gl.GL_LINES) gl.glVertex2f(cpi.x - self.tx, cpi.y - self.ty) gl.glVertex2f(cpo.x - self.tx, cpo.y - self.ty) gl.glEnd() show_bar(130, const.HEIGHT - 32, psc.fuel, psc.fuel_max, width=100., height=15., border_color=(255, 255, 255), progress=False) show_bar(485, const.HEIGHT - 32, psc.health, psc.health_max, width=100., height=15., border_color=(255, 255, 255), progress=False) show_bar(730, const.HEIGHT - 32, psc.passengers, self.manager.crew_to_rescue, width=100., height=15., border_color=(255, 255, 255), progress=False) seconds_remaining = self.manager.get_system(player.PlayerEscSystem.name()).time_limit / director.director.fps self.time_label.text = 'TIME %.2f' % seconds_remaining self.speed_label.text = 'SPEED %.2f' % ppc.vel.length self.fuel_label.draw() self.health_label.draw() self.rescued_label.draw() self.time_label.draw() self.speed_label.draw() self.controls_label.draw()
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) image_texture = image_data.get_texture() # texture size may be increased by pyglet to a power of 2 tw, th = image_texture.owner.width, image_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 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 extra_initgl(self): gl.glEnable( gl.GL_POINT_SMOOTH ) gl.glPointSize(5)
def set_state(self): super().set_state() gl.glLineWidth(self.width) gl.glPointSize(self.width)
def unset_state(self): gl.glPointSize(1.0)
def set_state(self): gl.glPointSize(self.size)
def point_size(self, value: float): gl.glPointSize(self._point_size) self._point_size = value
def set_state(self): gl.glPointSize(self.event.width + self.event.height)