def __init__(self, visions): self.visions = visions W, H = RENDER_SIZE pyglet.window.Window.__init__(self, caption='(pineal renderer)', fullscreen=0, width=W, height=H, vsync=0, visible=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.glEnable(gl.GL_POLYGON_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) self.texture = None
def _draw_rects(shape_list, vertex_vbo_id, texture_coord_vbo_id): """ Draw a set of rectangles using vertex buffers. This is more efficient than drawing them individually. """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_TEXTURE_2D) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST) # GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) # GL.glMatrixMode(GL.GL_MODELVIEW) # GL.glDisable(GL.GL_BLEND) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertex_vbo_id) GL.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY) GL.glEnableClientState(GL.GL_VERTEX_ARRAY) GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, texture_coord_vbo_id) offset = 0 for shape in shape_list: if shape.can_cache: texture_coord_vbo_id = None GL.glColor4f(1, 1, 1, shape.alpha) _render_rect_filled(shape, offset, shape.texture.texture_id, texture_coord_vbo_id) offset += 4 else: shape.draw()
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_rectangle_outline(center_x, center_y, width, height, color, border_width=1, tilt_angle=0): """ Draw a rectangle outline. Args: :x: x coordinate of top left rectangle point. :y: y coordinate of top left rectangle point. :width: width of the rectangle. :height: height of the rectangle. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :border_width: width of the lines, in pixels. :angle: rotation of the rectangle. Defaults to zero. Returns: None Raises: None Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> arcade.draw_rectangle_outline(278, 150, 45, 105, \ arcade.color.BRITISH_RACING_GREEN, 2) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() GL.glTranslatef(center_x, center_y, 0) if tilt_angle: GL.glRotatef(tilt_angle, 0, 0, 1) # Set line width GL.glLineWidth(border_width) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINE_LOOP) GL.glVertex3f(-width // 2, -height // 2, 0.5) GL.glVertex3f(width // 2, -height // 2, 0.5) GL.glVertex3f(width // 2, height // 2, 0.5) GL.glVertex3f(-width // 2, height // 2, 0.5) GL.glEnd()
def set_depth_test(self, on=True): """Enables z test. On by default""" if on: gl.glClearDepth(1.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) else: gl.glDisable(gl.GL_DEPTH_TEST)
def init_gl(self): gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glShadeModel(gl.GL_SMOOTH) gl.glBlendFunc(gl.GL_SRC_ALPHA,gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT,gl.GL_NICEST); #gl.glHint(gl.GL_POINT_SMOOTH_HINT,gl.GL_NICEST); #gl.glHint(gl.GL_LINE_SMOOTH_HINT,gl.GL_NICEST); gl.glDisable(gl.GL_DEPTH_TEST)
def enable(self): gl.glEnable(gl.GL_FOG) gl.glFogfv(gl.GL_FOG_COLOR, self.color) gl.glFogf(gl.GL_FOG_START, self.start) gl.glFogf(gl.GL_FOG_END, self.end) if self.density is not None: gl.glFogf(gl.GL_FOG_DENSITY, self.density) if self.hint is not None: gl.glHint(gl.GL_FOG_HINT, self.hint) gl.glFogi(gl.GL_FOG_MODE, self.equation)
def draw_lines(point_list, color, border_width=1): """ Draw a set of lines. Draw a line between each pair of points specified. Args: :point_list: List of points making up the lines. 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 Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> point_list = ((390, 450), \ (450, 450), \ (390, 480), \ (450, 480), \ (390, 510), \ (450, 510)) >>> arcade.draw_lines(point_list, arcade.color.BLUE, 3) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() # Set line width GL.glLineWidth(border_width) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINES) for point in point_list: GL.glVertex3f(point[0], point[1], 0.5) GL.glEnd()
def new_renderer(visions, size): """ Offscreen windows where render stuff """ W, H = size window = new_window(caption='(pineal renderer)', width=W, height=H, visible=0) window.visions = visions gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) window.texture = None # pyglet.clock.schedule_interval(window.update, 1.0/128.0) # pyglet.clock.set_fps_limit(30) @window.event def on_draw(): pyglet.clock.tick() window.clear() gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() (w, h) = window.get_size() gl.glScalef( float(min(w, h))/w, -float(min(w, h))/h, 1 ) gl.gluPerspective(45.0, 1, 0.1, 1000.0) gl.gluLookAt(0, 0, 2.4, 0, 0, 0, 0, 1, 0) for vision in window.visions.values(): gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() vision() buf = pyglet.image.get_buffer_manager().get_color_buffer() rawimage = buf.get_image_data() window.texture = rawimage.get_texture() return window
def init(self): ''' Set all initial OpenGL state, such as enabling DEPTH_TEST. ''' gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) self.backface_culling = True
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 _generic_draw_line_strip(point_list: PointList, color: Color, line_width: float = 1, mode: int = gl.GL_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 on_draw(): window.clear() gl.glColor4f(1.0,0,0,1.0) #glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) #glEnable (GL_BLEND) gl.glEnable (gl.GL_LINE_SMOOTH); gl.glHint (gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) gl.glLineWidth (3) pts = [] for (x,y) in turtle.points: pts.append(x) pts.append(y) pyglet.graphics.draw(len(turtle.points), pyglet.gl.GL_LINE_STRIP, ('v2f', tuple(pts)))
def draw_line(start_x, start_y, end_x, end_y, color, border_width=1): """ Draw a line. Args: :start_x: x position of line starting point. :start_y: y position of line starting point. :end_x: x position of line ending point. :end_y: y position of line ending point. :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 Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> arcade.draw_line(270, 495, 300, 450, arcade.color.WOOD_BROWN, 3) >>> color = (127, 0, 127, 127) >>> arcade.draw_line(280, 495, 320, 450, color, 3) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() # Set line width GL.glLineWidth(border_width) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINES) GL.glVertex3f(start_x, start_y, 0.5) GL.glVertex3f(end_x, end_y, 0.5) GL.glEnd()
def __init__(self): self.window = pyglet.window.Window(width=const.GAME_WIDTH, height=const.GAME_HEIGHT, vsync=False, caption="Porcupyne", resizable=True) self.window.invalid = False # resource.path = ['.'] res = resources.Resource() res.load_directory('gamedata') self.player1 = Ball(self, res) self.bg = BG(res) platform_width = 200 platform_height = 96 def get_points(x, y): x -= platform_width / 2.0 y -= platform_height / 2.0 return (((x, y), (x, y + platform_height), (x + platform_width, y + platform_height), (x + platform_width, y))) self.platforms = [ Platform(get_points(0, -128), res), Platform(get_points(128, 0), res), Platform(get_points(-270, -50), res), Platform(get_points(-320, 150), res), Platform(((225, 48), (400, 160), (400, 48)), res) ] self.controller = Controller(self.window, self.player1) self.fps_display = font.Text(pyglet.font.load('', 18, bold=True), '', color=(0.5, 0.5, 0.5, 0.5), x=-150, y=-100) ft = font.load('Arial', 10) color = (0, 0, 0, 1) self.debug_text = [ font.Text(ft, x=-150, y=100, color=color), font.Text(ft, x=-150, y=85, color=color), font.Text(ft, x=-150, y=70, color=color) ] # alpha channels¨ rabbyt.set_default_attribs() glEnable(GL_LINE_SMOOTH) glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
def init_gl(): gl.glClearDepth(1.0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDepthFunc(gl.GL_LEQUAL) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) gl.glShadeModel(gl.GL_SMOOTH) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
def initialize_gl(self): import pyglet.gl as gl # Set clear color gl.glClearColor(0, 0, 0, 0) # Set antialiasing gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) # Set alpha blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def draw_polygon_outline(point_list, color, border_width=1): """ Draw a polygon outline. Also known as a "line loop." Args: :point_list: List of points making up the lines. 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 >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> point_list = ((30, 240), \ (45, 240), \ (60, 255), \ (60, 285), \ (45, 300), \ (30, 300)) >>> arcade.draw_polygon_outline(point_list, arcade.color.SPANISH_VIOLET, 3) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) # Set line width GL.glLineWidth(border_width) GL.glLoadIdentity() # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINE_LOOP) for point in point_list: GL.glVertex3f(point[0], point[1], 0.5) GL.glEnd()
def init_gl_fog(self): """Configure the OpenGL fog properties.""" # Enable fog. Fog "blends a fog color with each rasterized pixel fragment's # post-texturing color." glEnable(GL_FOG) # Set the fog color. glFogfv(GL_FOG_COLOR, (GLfloat * 4)(0.5, 0.69, 1.0, 1)) # Say we have no preference between rendering speed and quality. glHint(GL_FOG_HINT, GL_DONT_CARE) # Specify the equation used to compute the blending factor. glFogi(GL_FOG_MODE, GL_LINEAR) # How close and far away fog starts and ends. The closer the start and end, # the denser the fog in the fog range. glFogf(GL_FOG_START, 20.0) glFogf(GL_FOG_END, 60.0)
def draw(self): # program['Projection'].write(get_projection().tobytes()) with self.vao: gl.glLineWidth(self.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) gl.glEnable(gl.GL_PRIMITIVE_RESTART) gl.glPrimitiveRestartIndex(2**32 - 1) self.vao.render(mode=self.mode)
def _initialize_opengl(self): # Initialize Modelview matrix gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() # Set antialiasing gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) # Set alpha blending gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glViewport(0, 0, 1024, 800)
def draw_rectangle_filled(center_x, center_y, width, height, color, tilt_angle=0): """ Draw a filled-in rectangle. Args: :x: x coordinate of top left rectangle point. :y: y coordinate of top left rectangle point. :width: width of the rectangle. :height: height of the rectangle. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :angle: rotation of the rectangle. Defaults to zero. Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> arcade.draw_rectangle_filled(390, 150, 45, 105, arcade.color.BLUSH) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glLoadIdentity() GL.glTranslatef(center_x, center_y, 0) if tilt_angle: GL.glRotatef(tilt_angle, 0, 0, 1) GL.glBegin(GL.GL_QUADS) GL.glVertex3f(-width // 2, -height // 2, 0.5) GL.glVertex3f(width // 2, -height // 2, 0.5) GL.glVertex3f(width // 2, height // 2, 0.5) GL.glVertex3f(-width // 2, height // 2, 0.5) GL.glEnd()
def draw(self): """ Draw everything in the list. """ # gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glLoadIdentity() gl.glTranslatef(self.center_x, self.center_y, 0) if self.angle: gl.glRotatef(self.angle, 0, 0, 1) last_color = None last_line_width = None 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) for shape in self.shape_list: if shape.vbo_color_id is not None: gl.glEnableClientState(gl.GL_COLOR_ARRAY) else: gl.glDisableClientState(gl.GL_COLOR_ARRAY) if last_color is None or last_color != shape.color: last_color = shape.color if len(shape.color) == 4: gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2], shape.color[3]) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) elif len(shape.color) == 3: gl.glDisable(gl.GL_BLEND) gl.glColor4ub(shape.color[0], shape.color[1], shape.color[2], 255) if shape.line_width and last_line_width != shape.line_width: last_line_width = shape.line_width gl.glLineWidth(shape.line_width) if shape.vbo_color_id is None: stripped_render(shape) else: stripped_render_with_colors(shape)
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 __init__(self): self.window = pyglet.window.Window(width = const.GAME_WIDTH, height = const.GAME_HEIGHT, vsync = False, caption = "Porcupyne", resizable = True) self.window.invalid = False # resource.path = ['.'] res = resources.Resource() res.load_directory('gamedata') self.player1 = Ball(self, res) self.bg = BG(res) platform_width = 200 platform_height = 96 def get_points(x, y): x -= platform_width / 2.0 y -= platform_height / 2.0 return (( (x, y), (x, y + platform_height), (x + platform_width, y + platform_height), (x + platform_width, y))) self.platforms = [ Platform(get_points(0, -128), res), Platform(get_points(128, 0), res), Platform(get_points(-270, -50), res), Platform(get_points(-320, 150), res), Platform(( (225, 48), (400, 160), (400, 48) ), res) ] self.controller = Controller(self.window, self.player1) self.fps_display = font.Text(pyglet.font.load('', 18, bold = True), '', color=(0.5, 0.5, 0.5, 0.5), x=-150, y=-100) ft = font.load('Arial', 10) color = (0, 0, 0, 1) self.debug_text = [font.Text(ft, x=-150, y=100, color = color), font.Text(ft, x=-150, y=85, color = color), font.Text(ft, x=-150, y=70, color = color)] # alpha channels¨ rabbyt.set_default_attribs() glEnable(GL_LINE_SMOOTH) glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
def draw_polygon_filled(point_list, color): """ Draw a polygon that is filled in. Args: :point_list: List of points making up the lines. 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. Returns: None Raises: None >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> point_list = ((150, 240), \ (165, 240), \ (180, 255), \ (180, 285), \ (165, 300), \ (150, 300)) >>> arcade.draw_polygon_filled(point_list, arcade.color.SPANISH_VIOLET) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_POLYGON) for point in point_list: GL.glVertex3f(point[0], point[1], 0.5) GL.glEnd()
def draw(self): """ Draw this shape. Drawing this way isn't as fast as drawing multiple shapes batched together in a ShapeElementList. """ assert(self.line_width == 1) gl.glLineWidth(self.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) gl.glEnable(gl.GL_PRIMITIVE_RESTART) gl.glPrimitiveRestartIndex(2 ** 32 - 1) self.vao.render(self.program, mode=self.mode)
def on_draw(self): gl.glEnable( gl.GL_POLYGON_SMOOTH ) #gl.glHint( gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST ) gl.glHint( gl.GL_POLYGON_SMOOTH_HINT, gl.GL_DONT_CARE ) gl.glEnable( gl.GL_LINE_SMOOTH ) gl.glEnable(gl.GL_MULTISAMPLE) gl.glEnable( gl.GL_BLEND) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) #gl.glBlendFunc( gl.GL_SRC_ALPHA_SATURATE, gl.GL_ONE) grey = 0.9 gl.glClearColor(grey, grey, grey, 0.0) gl.glPushMatrix() # I don't really know what the direction conventions for glTranslate are, # so the minus signs are from experimenting. #gl.glTranslatef(-self.viewportOrigin[0], -self.viewportOrigin[1], 0.0) self.clear() #self.grassBatch.draw() #self.wallImgBatch.draw() g = self.gameElements # Should I be pushing most of this code into GameElements? self.runner.on_draw() for z in self.zombies: #z.on_draw() pass gl.glPushMatrix() gl.glTranslatef(300, 300, 0.0) #gl.glScalef(0.5, 0.5, 0.0) self.countdowntimer.draw() gl.glPopMatrix() gl.glPopMatrix()
def run(): pyglet.options['audio'] = AUDIO_DRIVERS pyglet.options['debug_gl'] = False parser = OptionParser(description="%s: %s" % (APP_NAME, PROJECT_DESC), epilog='Project website: %s' % PROJECT_URL, version='%s %s' % (APP_NAME, VERSION), ) parser.add_option("-f", "--fullscreen", dest="fullscreen", default=False, action="store_true", ) parser.add_option("-d", "--debug", dest="debug", default=False, action="store_true", ) options, args = parser.parse_args() if options.debug: logging.basicConfig(level=logging.DEBUG) logging.debug("Debug enabled") logging.debug("Options: %s" % options) 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) # depth testing #gl.glEnable(gl.GL_DEPTH_TEST) plib.director.director.init(width=WIDTH, height=HEIGHT, fullscreen=options.fullscreen, caption=APP_NAME, debug=options.debug) plib.director.director.on_cleanup = on_cleanup app.init() plib.director.director.run()
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 on_draw(self): gl.glEnable(gl.GL_POLYGON_SMOOTH) #gl.glHint( gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST ) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_DONT_CARE) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_MULTISAMPLE) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) #gl.glBlendFunc( gl.GL_SRC_ALPHA_SATURATE, gl.GL_ONE) grey = 0.9 gl.glClearColor(grey, grey, grey, 0.0) gl.glPushMatrix() # I don't really know what the direction conventions for glTranslate are, # so the minus signs are from experimenting. #gl.glTranslatef(-self.viewportOrigin[0], -self.viewportOrigin[1], 0.0) self.clear() #self.grassBatch.draw() #self.wallImgBatch.draw() g = self.gameElements # Should I be pushing most of this code into GameElements? self.runner.on_draw() for z in self.zombies: #z.on_draw() pass gl.glPushMatrix() gl.glTranslatef(300, 300, 0.0) #gl.glScalef(0.5, 0.5, 0.0) self.countdowntimer.draw() gl.glPopMatrix() gl.glPopMatrix()
def _draw_rects(shape_list: Iterable[Sprite], vertex_vbo_id: gl.GLuint, texture_coord_vbo_id: gl.GLuint): """ Draw a set of rectangles using vertex buffers. This is more efficient than drawing them individually. """ gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_TEXTURE_2D) # As soon as this happens, can't use drawing commands gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) # gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # gl.glMatrixMode(gl.GL_MODELVIEW) # gl.glDisable(gl.GL_BLEND) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id) offset = 0 for shape in shape_list: if shape.can_cache: texture_coord_vbo_id = None gl.glColor4f(1, 1, 1, shape.alpha) _render_rect_filled(shape, offset, shape.texture.texture_id, texture_coord_vbo_id) offset += 4 else: shape.draw() gl.glDisable(gl.GL_TEXTURE_2D)
def __init__(self, width, height, display=None): display = get_display(display) self.width = width self.height = height self.window = pyglet.window.Window(width=width, height=height, display=display) self.window.on_close = self.window_closed_by_user self.geoms = [] self.onetime_geoms = [] self.transform = Transform() glEnable(GL_BLEND) # glEnable(GL_MULTISAMPLE) glEnable(GL_LINE_SMOOTH) # glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE) glHint(GL_LINE_SMOOTH_HINT, GL_NICEST) glLineWidth(2.0) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def setGL(self,cte): if cte == ANTI_ALIAS: gl.glEnable( gl.GL_BLEND) #~ gl.glBlendFunc(gl.GL_SRC_ALPHA_SATURATE, gl.GL_ONE); gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) #~ gl.glBlendFunc(gl.GL_SRC_ALPHA_SATURATE, gl.GL_ONE); #~ gl.glEnable( gl.GL_MULTISAMPLE ); #~ gl.glEnable(gl.GL_LINE_SMOOTH); #~ ; gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST); gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST); pass #~ class GL_Group_SegmentFill(gr.Group): #~ class GL_Group_SegmentFill(gr.Group): #~ def set_state(self): gl.glDisable(gl.GL_POLYGON_SMOOTH)
def convert_cml2png(formula, output): space = SpaceMock() batch = pyglet.graphics.Batch() img = Molecule(formula, space, batch, pos=(32,32), render_only=True) w, h, _ = img.cml.max_pos() width = int(w*64) + 64 height = int(h*64) + 64 config = gl.Config(double_buffer=True) window = pyglet.window.Window(width=width,height=height,visible=True,config=config) window.minimize() gl.glClearColor(250/256.0, 250/256.0, 250/256.0, 0) gl.glLineWidth(4) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) img.update() @window.event def on_draw(): window.clear() batch.draw() pyglet.image.get_buffer_manager().get_color_buffer().save(output) window.close() pyglet.app.exit() pyglet.app.run()
def __init__(self, visuals, **args): self.visuals = visuals pyglet.window.Window.__init__(self, **args) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable( gl.GL_VERTEX_ARRAY ) gl.glEnable( gl.GL_LINE_SMOOTH ) gl.glEnable( gl.GL_POLYGON_SMOOTH ) gl.glHint( gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST ) gl.glHint( gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST ) gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glShadeModel(gl.GL_SMOOTH) self.texture = None
def _draw_rects(shape_list: Iterable[Sprite], vertex_vbo_id: gl.GLuint, texture_coord_vbo_id: gl.GLuint): """ Draw a set of rectangles using vertex buffers. This is more efficient than drawing them individually. """ gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_TEXTURE_2D ) # As soon as this happens, can't use drawing commands gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) # gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # gl.glMatrixMode(gl.GL_MODELVIEW) # gl.glDisable(gl.GL_BLEND) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id) offset = 0 for shape in shape_list: if shape.can_cache: texture_coord_vbo_id = None gl.glColor4f(1, 1, 1, shape.alpha) _render_rect_filled(shape, offset, shape.texture.texture_id, texture_coord_vbo_id) offset += 4 else: shape.draw() gl.glDisable(gl.GL_TEXTURE_2D)
def __init__(self, width=800, height=600): if settings['fullscreen']: pyglet.window.Window.__init__(self, fullscreen=True) else: pyglet.window.Window.__init__(self, width=width, height=height) self.set_caption("Elite Bungie Chopper Squadron") self.fps_display = pyglet.clock.ClockDisplay() self.keys = pyglet.window.key.KeyStateHandler( ) # What keys/commands are currently being pressed? self.push_handlers(self.keys) self.timer = util.fixedsteploop.FixedStepLoop(self.update, TIME_STEP, MAX_CYCLES_PER_FRAME) self.game = game.Game(self.keys, self) self.game.load_stage("00", True) self.menu = menu.Menu(self) self.state = self.menu self.push_handlers(self.menu) self.timer.play() gl.glClearColor(128, 128, 255, 255) gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glShadeModel(gl.GL_SMOOTH) # Enables Smooth Shading gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) #Type Of Blending To Perform gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) #Really Nice Perspective Calculations gl.glHint(gl.GL_POINT_SMOOTH_HINT, gl.GL_NICEST) #Really Nice Point Smoothing gl.glDisable(gl.GL_DEPTH_TEST) self.clear() resources.chopper_blades.play()
def setup(self): self.camera = PlotCamera(self, ortho=self.ortho) self.controller = PlotController(self, invert_mouse_zoom=self.invert_mouse_zoom) self.push_handlers(self.controller) pgl.glClearColor(1.0, 1.0, 1.0, 0.0) pgl.glClearDepth(1.0) pgl.glDepthFunc(pgl.GL_LESS) pgl.glEnable(pgl.GL_DEPTH_TEST) pgl.glEnable(pgl.GL_LINE_SMOOTH) pgl.glShadeModel(pgl.GL_SMOOTH) pgl.glLineWidth(self.linewidth) pgl.glEnable(pgl.GL_BLEND) pgl.glBlendFunc(pgl.GL_SRC_ALPHA, pgl.GL_ONE_MINUS_SRC_ALPHA) if self.antialiasing: pgl.glHint(pgl.GL_LINE_SMOOTH_HINT, pgl.GL_NICEST) pgl.glHint(pgl.GL_POLYGON_SMOOTH_HINT, pgl.GL_NICEST) self.camera.setup_projection()
def __init__(self, width, height, visible, display=None, background_rgb=(1, 1, 1)): display = get_display(display) self.width = width self.height = height self.background_rgb = background_rgb self.window = pyglet.window.Window(width=width, height=height, display=display, visible=visible) if not visible: # get around stupid bug (?) where OpenGL refuses to render anything # to FBOs until the window is displayed self.window.set_visible(True) self.window.set_visible(False) # need to use a second FBO to actually get image data self.render_fbo = get_offscreen_fbo(width, height, msaa_samples=1) self.no_msaa_fbo = get_offscreen_fbo(width, height, msaa_samples=1) self.window.on_close = self.window_closed_by_user self.isopen = True self.reset_geoms() self.transforms = Transform() gl.glEnable(gl.GL_BLEND) # tricks from OpenAI's multiagent particle env repo: # gl.glEnable(gl.GL_MULTISAMPLE) gl.glEnable(gl.GL_LINE_SMOOTH) # gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(2.0) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def __init__(self): self._stroke_color = (1, 1, 1, 1) self._fill_color = (1, 1, 1, 1) self._line_width = 1 glEnable(GL_POINT_SMOOTH) glEnable(GL_LINE_SMOOTH) glEnable(GL_POLYGON_SMOOTH) glHint(GL_POINT_SMOOTH_HINT, GL_NICEST) glHint(GL_LINE_SMOOTH_HINT, GL_NICEST) glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST)
def set_state(self): super().set_state() # enable alpha colors gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # enable anti-aliasing gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glHint(gl.GL_POINT_SMOOTH_HINT, self.quality) gl.glHint(gl.GL_LINE_SMOOTH_HINT, self.quality) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, self.quality)
def __init__(self, my_gen): self.my_gen = my_gen super(MapGenWindow, self).__init__(width=800, height=800) gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glShadeModel(gl.GL_SMOOTH) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) gl.glHint(gl.GL_POINT_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glDisable(gl.GL_DEPTH_TEST) self.landmass = self.my_gen.generate() self.draw_capitals = True self.labels = [] self.batch = pyglet.graphics.Batch() self.update() pyglet.app.run()
def on_draw(self): if (not self.e.period is None) and (not self.e.filename is None): if True: #not os.path.isfile(self.e.filename): if self.e.time() > self.e.period: pyglet.app.exit() self.clear() gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() # gluOrtho2D sets up a two-dimensional orthographic viewing region. # Parameters left, right # Specify the coordinates for the left and right vertical clipping planes. # bottom, top # Specify the coordinates for the bottom and top horizontal clipping planes. # Description # gl.gluOrtho2D(-(self.W-1)/2*self.e.total_width, (self.W+1)/2*self.e.total_width, -self.e.total_width/2, self.e.total_width/2, 0, 0, 1); self.W = float(self.width) / self.height gl.gluOrtho2D(-self.W / 2 * self.e.total_width, self.W / 2 * self.e.total_width, -self.e.total_width / 2, self.e.total_width / 2, 0, 0, 1) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() #gl.glLineWidth () #p['line_width']) gl.glEnable(gl.GL_BLEND) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glColor3f(0., 0., 0.) if self.first_frame: # print(self.e.t0, self.e.t) self.e.t0 = time.time() self.e.t = self.e.time() # print(self.e.t0, self.e.t) self.first_frame = False dt = self.e.time() - self.e.t if 1. / self.e.desired_fps - dt > 0.: time.sleep(1. / self.e.desired_fps - dt) self.e.receive() X, Y, Theta = self.e.lames[0, :], self.e.lames[1, :], self.e.lames[ 2, :] dX, dY = np.cos(Theta) / 2., np.sin(Theta) / 2. #print(Theta) # coords = np.vstack((X-dX*self.e.lame_length, Y-dY*self.e.lame_length, X+dX*self.e.lame_length, Y+dY*self.e.lame_length)) coords = np.vstack(( X - dX * self.e.lame_length + dY * self.e.lame_width, Y - dY * self.e.lame_length - dX * self.e.lame_width, X + dX * self.e.lame_length + dY * self.e.lame_width, Y + dY * self.e.lame_length - dX * self.e.lame_width, X - dX * self.e.lame_length - dY * self.e.lame_width, Y - dY * self.e.lame_length + dX * self.e.lame_width, X + dX * self.e.lame_length - dY * self.e.lame_width, Y + dY * self.e.lame_length + dX * self.e.lame_width, )) #pyglet.graphics.draw(2*self.e.N_lame, gl.GL_LINES, ('v2f', coords.T.ravel().tolist())) if True: indices = np.array([ 0, 1, 2, 1, 2, 3 ])[:, np.newaxis] + 4 * np.arange(self.e.N_lame) pyglet.graphics.draw_indexed( 4 * self.e.N_lame, pyglet.gl.GL_TRIANGLES, indices.T.ravel().tolist(), ('v2f', coords.T.ravel().tolist())) #pyglet.graphics.draw(4*self.e.N_lame, gl.GL_QUADS, ('v2f', coords.T.ravel().tolist())) # carré if self.e.DEBUG: coords = np.array([[ -.5 * self.e.total_width, .5 * self.e.total_width, .5 * self.e.total_width, -.5 * self.e.total_width ], [ -.5 * self.e.total_width, -.5 * self.e.total_width, .5 * self.e.total_width, .5 * self.e.total_width ]]) pyglet.graphics.draw(4, gl.GL_LINE_LOOP, ('v2f', coords.T.ravel().tolist())) # centres des lames if self.e.DEBUG: gl.glLineWidth(1.) gl.glColor3f(0., 0., 0.) pyglet.graphics.draw( self.e.N_lame, gl.GL_POINTS, ('v2f', self.e.lames[:2, :].T.ravel().tolist())) gl.glColor3f(1., 0., 0.) pyglet.graphics.draw(2, gl.GL_LINES, ('v2f', [0., 0., 1., 0.])) gl.glColor3f(0., 1., 0.) pyglet.graphics.draw(2, gl.GL_LINES, ('v2f', [0., 0., 0., 1.])) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() self.label.draw() self.text.draw()
def _draw_rects(shape_list: List[Sprite], vertex_buffer: VertexBuffer, texture_coord_buffer: TextureCoordBuffer, color_buffer: ColorBuffer, change_x: float, change_y: float): """ Draw a set of rectangles using vertex buffers. This is more efficient than drawing them individually. """ if len(shape_list) == 0: return gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_TEXTURE_2D) # As soon as this happens, can't use drawing commands gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) vertex_buffer.bind() color_buffer.bind() texture_coord_buffer.bind() gl.glLoadIdentity() gl.glTranslatef(change_x, change_y, 0) # Ideally, we want to draw these in "batches." # We seek to find groups of squares with the same texture. Then draw # them all at once. last_texture_id = None batch_count = 0 offset = 0 batch_offset = 0 texture_coord_vbo_id = None for shape in shape_list: if shape.texture.texture_id != last_texture_id: # Ok, if the 'if' triggered above, we are now looking at a different # texture than we looked at with the last loop. So draw the last # "batch" of squares. We'll start a new batch with the current # square but not draw it yet if batch_count > 0: _render_rect_filled(batch_offset, last_texture_id, texture_coord_vbo_id, batch_count) batch_count = 0 batch_offset = offset last_texture_id = shape.texture.texture_id batch_count += 4 offset += 4 # Draw the last batch, if it exists _render_rect_filled(batch_offset, last_texture_id, texture_coord_vbo_id, batch_count) # Must do this, or drawing commands won't work. gl.glDisable(gl.GL_TEXTURE_2D)
self._title = caption def update_caption(self, mouse): """ 添加坐标显示 """ caption = "{} x: {}, y: {}".format(self._title, mouse.x, mouse.y) super().set_caption(caption) def clear(self): all_shapes.clear() super().clear() def show_axis(self): from pyleap import Line, Text for x in range(0, window.w, 100): Line(x, 0, x, window.h, 1, '#eeaa00').draw() Text(str(x), x + 2, 2, 10).draw() for y in range(0, window.h, 100): Line(0, y, window.w, y, 1, '#eeaa00').draw() Text(str(y), 2, y + 2, 10).draw() window = Window() # alpha gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POLYGON_SMOOTH) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_DONT_CARE)
def draw_ellipse_filled(center_x, center_y, width, height, color, tilt_angle=0): """ Draw a filled in ellipse. Args: :center_x: x position that is the center of the circle. :center_y: y position that is the center of the circle. :height: height of the ellipse. :width: width of the ellipse. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :angle: Angle in degrees to tilt the ellipse. :num_segments: number of triangle segments that make up this circle. Higher is better quality, but slower render time. 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_ellipse_filled(60, 81, 15, 36, arcade.color.AMBER) >>> color = (127, 0, 127, 127) >>> arcade.draw_ellipse_filled(60, 144, 15, 36, color, 45) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ num_segments = 128 GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() GL.glTranslatef(center_x, center_y, 0) GL.glRotatef(tilt_angle, 0, 0, 1) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_TRIANGLE_FAN) GL.glVertex3f(0, 0, 0.5) for i in range(num_segments + 1): theta = 2.0 * 3.1415926 * i / num_segments x = width * math.cos(theta) y = height * math.sin(theta) GL.glVertex3f(x, y, 0.5) GL.glEnd() GL.glLoadIdentity()
def draw_ellipse_outline(center_x, center_y, width, height, color, border_width=1, tilt_angle=0): """ Draw the outline of an ellipse. Args: :center_x: x position that is the center of the circle. :center_y: y position that is the center of the circle. :height: height of the ellipse. :width: width of the ellipse. :color: color, specified in a list of 3 or 4 bytes in RGB or RGBA format. :border_width: Width of the circle outline in pixels. :tilt_angle: Angle in degrees to tilt the ellipse. 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_ellipse_outline(540, 273, 15, 36, arcade.color.AMBER, 3) >>> color = (127, 0, 127, 127) >>> arcade.draw_ellipse_outline(540, 336, 15, 36, color, 3, 45) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ num_segments = 128 GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glLoadIdentity() GL.glTranslatef(center_x, center_y, 0) GL.glRotatef(tilt_angle, 0, 0, 1) GL.glLineWidth(border_width) # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINE_LOOP) for i in range(num_segments): theta = 2.0 * 3.1415926 * i / num_segments x = width * math.cos(theta) y = height * math.sin(theta) GL.glVertex3f(x, y, 0.5) GL.glEnd() GL.glLoadIdentity()
def init_gl(self): """ Perform the magic incantations to create an OpenGL scene. """ # default background color is white-ish background = [.99, .99, .99, 1.0] # if user passed a background color use it if 'background' in self.kwargs: try: # convert to (4,) uint8 RGBA background = to_rgba(self.kwargs['background']) # convert to 0.0 - 1.0 float background = background.astype(np.float64) / 255.0 except BaseException: log.error('background color wrong!', exc_info=True) # apply the background color gl.glClearColor(*background) 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 _initGL(self): gl.glClearColor(0.8, 0.8, 0.9, 0) gl.glClearDepth(1.0) # Enables Clearing Of The Depth Buffer gl.glDepthFunc(gl.GL_LESS) # The Type Of Depth Test To Do gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) # make stuff look nice gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) if self.anti_alias: gl.glLineWidth(0.1) else: gl.glLineWidth(1.0) #gl.glEnable(gl.GL_BLEND) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) # Enables Depth Testing gl.glEnable(gl.GL_LIGHTING) #gl.glEnable(gl.GL_NORMALIZE) #gl.glLightModeli(gl.GL_LIGHT_MODEL_TWO_SIDE, gl.GL_FALSE) if not gl.glUseProgram: print("Can't run shaders!") sys.exit(1) self.default_shader = compileProgram( compileShader( ''' varying vec3 vN; varying vec3 v; void main(void) { v = vec3(gl_ModelViewMatrix * gl_Vertex); vN = normalize(gl_NormalMatrix * gl_Normal); gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; } ''', gl.GL_VERTEX_SHADER), compileShader( ''' varying vec3 vN; varying vec3 v; #define MAX_LIGHTS 1 void main (void) { vec3 N = normalize(vN); vec4 finalColor = vec4(0.0, 0.0, 0.0, 0.0); for (int i=0;i<MAX_LIGHTS;i++) { vec3 L = normalize(gl_LightSource[i].position.xyz - v); vec3 E = normalize(-v); // we are in Eye Coordinates, so EyePos is (0,0,0) vec3 R = normalize(-reflect(L,N)); //calculate Ambient Term: vec4 Iamb = gl_FrontLightProduct[i].ambient; //calculate Diffuse Term: vec4 Idiff = gl_FrontLightProduct[i].diffuse * max(dot(N,L), 0.0); Idiff = clamp(Idiff, 0.0, 1.0); // calculate Specular Term: vec4 Ispec = gl_FrontLightProduct[i].specular * pow(max(dot(R,E),0.0),0.3*gl_FrontMaterial.shininess); Ispec = clamp(Ispec, 0.0, 1.0); finalColor += Iamb + Idiff + Ispec; } // write Total Color: gl_FragColor = gl_FrontLightModelProduct.sceneColor + finalColor; } ''', gl.GL_FRAGMENT_SHADER), ) self.cube_list = Cube().getVerticeList() self.coord_list = Coord().getVerticeList() self.grid_list = Grid().getVerticeList() # fill later self.mesh_lists = {} # type: Dict[str, Any]
def draw_line_strip(point_list, color, border_width=1): """ 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 Example: >>> import arcade >>> arcade.open_window("Drawing Example", 800, 600) >>> arcade.set_background_color(arcade.color.WHITE) >>> arcade.start_render() >>> point_list = ((510, 450), \ (570, 450), \ (510, 480), \ (570, 480), \ (510, 510), \ (570, 510)) >>> arcade.draw_line_strip(point_list, arcade.color.TROPICAL_RAIN_FOREST, \ 3) >>> color = (127, 0, 127, 127) >>> point_list = ((510, 455), \ (570, 455), \ (510, 485), \ (570, 485), \ (510, 515), \ (570, 515)) >>> arcade.draw_line_strip(point_list, color, 3) >>> arcade.finish_render() >>> arcade.quick_run(0.25) """ GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) # Set line width GL.glLineWidth(border_width) GL.glLoadIdentity() # Set color if len(color) == 4: GL.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: GL.glColor4ub(color[0], color[1], color[2], 255) GL.glBegin(GL.GL_LINE_STRIP) for point in point_list: GL.glVertex3f(point[0], point[1], 0.5) GL.glEnd()
def _draw_rects(shape_list: List[Sprite], vertex_vbo_id: gl.GLuint, texture_coord_vbo_id: gl.GLuint, change_x: float, change_y: float): """ Draw a set of rectangles using vertex buffers. This is more efficient than drawing them individually. """ if len(shape_list) == 0: return gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_TEXTURE_2D ) # As soon as this happens, can't use drawing commands # gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) # gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) # gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # gl.glMatrixMode(gl.GL_MODELVIEW) # gl.glDisable(gl.GL_BLEND) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vertex_vbo_id) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, texture_coord_vbo_id) last_alpha = shape_list[0].alpha gl.glColor4f(1, 1, 1, last_alpha) gl.glLoadIdentity() # gl.glLoadIdentity() gl.glTranslatef(change_x, change_y, 0) # Ideally, we want to draw these in "batches." # We seek to find groups of squares with the same texture. Then draw # them all at once. last_texture_id = None last_alpha = 1 batch_count = 0 offset = 0 batch_offset = 0 texture_coord_vbo_id = None for shape in shape_list: if shape.texture.texture_id != last_texture_id or shape.alpha != last_alpha: # Ok, if the 'if' triggered above, we are now looking at a different # texture than we looked at with the last loop. So draw the last # "batch" of squares. We'll start a new batch with the current # square but not draw it yet if batch_count > 0: gl.glColor4f(1, 1, 1, last_alpha) _render_rect_filled(batch_offset, last_texture_id, texture_coord_vbo_id, batch_count) batch_count = 0 batch_offset = offset last_texture_id = shape.texture.texture_id last_alpha = shape.alpha batch_count += 4 offset += 4 # Draw the last batch, if it exists _render_rect_filled(batch_offset, last_texture_id, texture_coord_vbo_id, batch_count) gl.glDisable(gl.GL_TEXTURE_2D)
def on_draw(self): gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) self.clear() self.gamePhase.draw(self)