def bind_texture_region(texture, x, y, w, h, premultiplied=False, flip=False): gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glEnable(gl.GL_SCISSOR_TEST) gl.glEnable(gl.GL_BLEND) if premultiplied: gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA) else: gl.glBlendFuncSeparate(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA, gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() gl.glViewport(x, y, w, h) gl.glScissor(x, y, w, h) gl.glBindFramebufferEXT(gl.GL_DRAW_FRAMEBUFFER_EXT, Manager.col_buffer.gl_buffer) gl.glFramebufferTexture2DEXT(gl.GL_DRAW_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT, texture.target, texture.id, 0) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() if flip: gl.gluOrtho2D(0, w, h, 0) else: gl.gluOrtho2D(0, w, 0, h)
def render(self): """Render all lights.""" gl.glEnable(gl.GL_TEXTURE_2D) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, self.fbo.textures[0]) lighting_shader.bind() lighting_shader.uniformi('diffuse_tex', 0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) vpw = self.viewport.w vph = self.viewport.h vpx, vpy = self.viewport.position vpradius = sqrt(vpw * vpw + vph * vph) * 0.5 c = 0 for light in self.lights: lx, ly = light.position maxdist = light.radius + vpradius dx = vpx - lx * self.tilew dy = vpy - ly * self.tilew dist = sqrt(dx * dx + dy * dy) if dist < maxdist: self.render_light(light) c += 1 lighting_shader.unbind() # Draw ambient using a full-screen quad gl.glColor3f(*self.ambient) self.viewport.draw_quad() gl.glColor4f(1, 1, 1, 1) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def main(): global gJoyStick global show gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glEnable( gl.GL_BLEND) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) #pyglet.clock.set_fps_limit(60) pyglet.clock.schedule_interval(update, 1/30.) window.set_vsync(True) for x in pyglet.input.get_joysticks(): #readStick(x) pass gJoyStick = pyglet.input.get_joysticks()[0] gJoyStick.open() for x in gJoyStick.device.get_controls(): #print x pass if len(sys.argv) > 1 and sys.argv[1] == '-b': show = 'buttons' else: show = 'axes' pyglet.app.run() print ""
def setup(): """ Basic OpenGL configuration. """ # Set the color of "clear", i.e. the sky, in rgba. gl.glClearColor(0.5, 0.69, 1.0, 1) # Enable culling (not rendering) of back-facing facets -- facets that aren't # visible to you. gl.glEnable(gl.GL_CULL_FACE) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_DST_ALPHA) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glBlendFunc(gl.GL_ZERO, gl.GL_SRC_COLOR) gl.glEnable(gl.GL_BLEND) gl.glAlphaFunc(gl.GL_GREATER, 0.5); gl.glEnable(gl.GL_ALPHA_TEST); # Set the texture minification/magnification function to GL_NEAREST (nearest # in Manhattan distance) to the specified texture coordinates. GL_NEAREST # "is generally faster than GL_LINEAR, but it can produce textured images # with sharper edges because the transition between texture elements is not # as smooth." gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) setup_fog()
def setupOpenGL(self): gl.glClearColor(0., 0., 0., 1.) gl.glColor4f(1.0, 0.0, 0.0, 0.5) gl.glEnable(gl.GL_DEPTH_TEST) #gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def on_draw(): gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() # Gradient sky l, b = world_to_screen((0, 0)) r, t = world_to_screen((W, H)) horizon = 177 / 255.0, 202 / 255.0, 1.0 zenith = 68 / 255.0, 0.5, 1.0 pyglet.graphics.draw(4, gl.GL_QUADS, ('v2f', [l, b, l, t, r, t, r, b]), ('c3f', sum([horizon, zenith, zenith, horizon], ())), ) cx, cy = camera tx, ty = world_to_screen((-cx + W * 0.5, -cy + H * 0.5)) gl.glTranslatef(tx, ty, 0) batch.draw() # Water l, b = world_to_screen((0, 0)) r, t = world_to_screen((1000, WATER_LEVEL)) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) pyglet.graphics.draw(4, gl.GL_QUADS, ('v2f', [l, b, l, t, r, t, r, b]), ('c4f', [0, 0.2, 0.8, 0.5] * 4), )
def draw(self, delta): if len(self._queue) == 0: return # self.clear_screen() self.setup_shader_program_if_needed() for layer in self._queue: if len(layer._queue) == 0 or not layer.visible: continue if layer.vao is None: layer.rasterize() layer.gl_texture.use(1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) with layer.vao: self.program['Texture'] = 1 # self.texture_id self.program['Projection'] = get_projection().flatten() layer.gl_data_buf.write(layer.sprite_data) layer.vao.render(gl.GL_TRIANGLE_STRIP, instances=len(layer._queue)) layer.gl_data_buf.orphan() layer.visible = False layer.vao = None
def __init__(self, rows, columns, n_apples, *args, **kwargs): super(PygletEngine, self).__init__(rows, columns, n_apples, *args, **kwargs) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) pyglet.clock.schedule_interval(lambda t: self.update_snakes(), 1/30.0)
def draw(self): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LEQUAL) dx = self.tile_size[0] dy = self.tile_size[1] stack = self.half_stack # terrain pass x, y = self.start_x, self.start_y for row in self.__map: x = self.start_x for tile, item in row: tile.blit(x, y, 0) x += dx y += dy # bullet pass for bullet in self.bullets: bullet.draw() # item pass x, y = self.start_x, self.start_y for row in self.__map: x = self.start_x for tile, item in row: if item is not None: item.blit(x, y + stack, 1) x += dx y += dy
def interact(bld, fullscreen=False): # pragma: no cover """Interact with the billiard simulation. Args: bld: A billiard simulation. fullscreen (optional): Set window to fullscreen, defaults to False. """ # print instructions print("Play/Pause: Space, move: WASD, zoom: QE, simspeed: RF, exit: Esc") # create window window = BilliardWindow(bld, width=800, height=600, resizable=True) if fullscreen: window.set_fullscreen() # OpenGL settings for high quality line drawing 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(pyglet.gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLineWidth(2) # show window, start simulation pyglet.app.run()
def render_skybox(self): import pyglet.gl as gl gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) tex = self.skyboxTexture vs = \ ( # vertices are represented as 2 element floats self._anchorX, self._anchorY, (self._width + self._anchorX), self._anchorY, (self._width + self._anchorX), (self._height + self._anchorY), self._anchorX, (self._height + self._anchorY), ) #divide the skybox into 360 degrees horizontally and 180 vertically #calculate the amount of skybox to display based on FOV: hRat = self.camera.FOV / 2 / 360 vRat = np.arctan(np.tan(hRat * 2 * np.pi) * self._height / self._width) ts = \ ( # texture coordinates as a float, 0.0, 0.5, 1.0, 0.5, 1.0, 0.0, 0.0, 0.0, ) vList = pyglet.graphics.vertex_list(4, ('v2f', vs), ('t2f', ts)) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, tex.id) vList.draw(pyglet.gl.GL_QUADS) gl.glDisable(gl.GL_TEXTURE_2D)
def __init__(self): super().__init__(resizable=True) self.maximize() self.set_minimum_size(*const.MAIN_MIN_SIZE) self.set_caption(const.MAIN_TITLE) # Blend alpha so that the more shapes overlap, the less transparent the intersection area. gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) pyglet.clock.set_fps_limit(const.FPS) self.items = [] # All items rendered within this window self.dragged_items = [] # Items being dragged at the moment self.move_vectors = {} # Vectors for random movement self.fullscreen_flag = False self.multidrag_flag = True # Whether all overlapping items or only the uppermost one should be dragged. self.random_move_flag = False # Whether shapes should be automatically moved self.creation_flags = const.CREATE_NONE # This will be popped off when needed self.push_handlers(on_mouse_press=self.select_items, on_mouse_drag=self.drag_items, on_mouse_release=self.release_items) self.push_handlers(on_mouse_press=self.check_buttons) self.update_buttons()
def draw(self, frame): # The gneneral plan here is: # 1. Get the dots in the range of 0-255. # 2. Create a texture with the dots data. # 3. Draw the texture, scaled up with nearest-neighbor. # 4. Draw a mask over the dots to give them a slightly more realistic look. gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glLoadIdentity() # Draw the dots in this color: #gl.glColor3f(1.0, 0.5, 0.25) gl.glScalef(1, -1, 1) gl.glTranslatef(0, -DMD_SIZE[1]*DMD_SCALE, 0) #data = frame.get_data_mult() #this new jk_get_data will read the dots using the dmd function #and convert them via the map to rGB. data = self.jk_get_data(frame) image = pyglet.image.ImageData(DMD_SIZE[0], DMD_SIZE[1], 'RGB', data, pitch=DMD_SIZE[0] * 3) gl.glTexParameteri(image.get_texture().target, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) image.blit(0, 0, width=DMD_SIZE[0]*DMD_SCALE, height=DMD_SIZE[1]*DMD_SCALE) del image gl.glScalef(DMD_SCALE/float(MASK_SIZE), DMD_SCALE/float(MASK_SIZE), 1.0) gl.glColor4f(1.0, 1.0, 1.0, 1.0) self.mask_texture.blit_tiled(x=0, y=0, z=0, width=DMD_SIZE[0]*MASK_SIZE, height=DMD_SIZE[1]*MASK_SIZE)
def __init__(self): super(Evolves, self).__init__(caption="Evolves 2008", width=100, height=100) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.setup()
def __init__(self, x=500, y=500, visible=False): super(Drawer, self).__init__(x, y) self.set_visible(visible) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.main_batch = pyglet.graphics.Batch() self.scrot_name = None
def init(cls, caption: str, vsync: bool, w: int, h: int): cls.window = pyglet.window.Window(caption=caption, vsync=vsync, width=w, height=h) cls.window.push_handlers(cls.keys) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glEnable(pyglet.gl.GL_ALPHA_TEST) glAlphaFunc(pyglet.gl.GL_GREATER, .1) cls.window.on_draw = cls.on_draw from gameengine.managers.InputManager import InputManager cls.window.on_mouse_motion = InputManager().on_mouse_motion cls.window.on_mouse_press = InputManager().on_mouse_press cls.window.on_mouse_release = InputManager().on_mouse_release cls.window.on_mouse_drag = InputManager().on_mouse_drag cls.window.on_mouse_scroll = InputManager().on_mouse_scroll cls.window.on_key_press = InputManager().on_key_press cls.window.on_key_release = InputManager().on_key_release cls.fps_display = pyglet.window.FPSDisplay(cls.window)
def draw_ellipse_filled(center_x: float, center_y: float, width: float, height: float, color: Color, tilt_angle: float = 0): num_segments = 128 gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) gl.glLoadIdentity() gl.glTranslatef(center_x, center_y, 0) gl.glRotatef(tilt_angle, 0, 0, 1) # Set color if len(color) == 4: gl.glColor4ub(color[0], color[1], color[2], color[3]) elif len(color) == 3: gl.glColor4ub(color[0], color[1], color[2], 255) gl.glBegin(gl.GL_TRIANGLE_FAN) gl.glVertex3f(0, 0, 0.5) for segment in range(num_segments + 1): theta = 2.0 * 3.1415926 * segment / num_segments x = width * math.cos(theta) y = height * math.sin(theta) gl.glVertex3f(x, y, 0.5) gl.glEnd() gl.glLoadIdentity()
def on_draw(self): """Redraw the current image.""" # the pyglet.window docs specify: # > The window will already have the GL context, so there is no need to # > call `.switch_to`. The window’s `.flip` method will be called after # > this event, so your event handler should not. # self.switch_to() # gl.glClearColor(0, 0, 0, 0) self.clear() if hasattr(self, 'texture'): # do not interpolate when resizing textures gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) # textures with alpha channels require gl blending capability gl.glEnable(gl.GL_BLEND) # Additive blending `R = S * F_s + D * F_d` for `c4f` f-RGBA gl.glBlendEquation(gl.GL_FUNC_ADD) # Factors `F_s = S_a` and `F_d = 1 - S_a` give transparency fx, # >>> gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # but we set `F_s = 1.` and `F_d = 0.` for complete overwrite. # see https://learnopengl.com/Advanced-OpenGL/Blending # and https://www.khronos.org/opengl/wiki/Blending # and https://stackoverflow.com/a/18497511 (for opacity eqn) gl.glBlendFunc(gl.GL_ONE, gl.GL_ZERO) # draw the image data into the window's buffer as a texture # blit transforms the texture data only virtually: the texture's # `.width` and `.height` dims still retain original array's shape. self.texture.blit(0, 0, width=self.width, height=self.height)
def setup(): """ Basic OpenGL configuration. """ # Set the color of "clear", i.e. the sky, in rgba. gl.glClearColor(0.5, 0.69, 1.0, 1) # Enable culling (not rendering) of back-facing facets -- facets that aren't # visible to you. gl.glEnable(gl.GL_CULL_FACE) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_DST_ALPHA) #gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glBlendFunc(gl.GL_ZERO, gl.GL_SRC_COLOR) gl.glEnable(gl.GL_BLEND) gl.glAlphaFunc(gl.GL_GREATER, 0.5) gl.glEnable(gl.GL_ALPHA_TEST) # Set the texture minification/magnification function to GL_NEAREST (nearest # in Manhattan distance) to the specified texture coordinates. GL_NEAREST # "is generally faster than GL_LINEAR, but it can produce textured images # with sharper edges because the transition between texture elements is not # as smooth." gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE) setup_fog()
def __init__(self, *args, **kwargs): super(VIctorApp, self).__init__(640, 400, caption="victor") self.set_default_options() self.mode = vmode.NORMAL self.down_action = None self.text_event = None self.batch = pyglet.graphics.Batch() self.setup_cursor() self.marks = dict() self.command_area = CommandArea(0, 0, 550, self.batch) self.keystrokes = Keystrokes(550, 0, 70, self.batch) self.current_multiplier = None self.normal_dispatcher = vnd.construct_dispatcher(self) self.set_ex_commands() self.groups = self.current_group = PathGroup() self.current_path = None self.time = time.time() pyglet.clock.schedule_interval(self.on_timer_fire, 0.05) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND)
def __init__(self, *args, **kwargs): pyglet.window.Window.__init__(self, *args, **kwargs) self.set_exclusive_keyboard(False) pyglet.clock.schedule_interval(lambda _: None, 0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.states = [MainMenu(self)] #PlayLevel(self,*GRID_SIZE)
def on_resize(width, height): pgl.glBlendFunc(pgl.GL_SRC_ALPHA, pgl.GL_ONE_MINUS_SRC_ALPHA) pgl.glViewport(0, 0, 400, 400) #pgl.glEnable(pgl.GL_CULL_FACE) pgl.glScalef(100, 100, 0.01) pgl.glTranslatef(2, 2, 2) pgl.glRotatef(10, 0, 0, 1)
def 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(self): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glColor4f(*(list(SELECTED_COLOUR) + [0.5])) self.inner_circle.draw() gl.glColor3f(*SELECTED_COLOUR) self.circle.draw() pyglet.graphics.draw( len(self.vs) // 2, gl.GL_LINES, ('v2f', self.vs), ) if self.angle is not None: centre = self.circle.centre radius = self.circle.radius l = 10 avs = list( walk([ centre + v(radius + 4, 0).rotated(self.angle), centre + v(radius + 4 + l, 0).rotated(self.angle) ])) pyglet.graphics.draw( 2, gl.GL_LINES, ('v2f', avs), ) pos = centre + v(radius + 6 + l, 0).rotated(self.angle) self.label.x, self.label.y = pos self.label.anchor_x = 'right' if self.label.x < centre.x else 'left' self.label.draw() self.label.draw() # Draw twice because it doesn't come out well
def draw(self): if self._dirty: self._context = Context() self._parts = [] self.free() self.render() self.build_vbo() self._dirty = False # set gl.glEnable(self._texture.target) gl.glBindTexture(self._texture.target, self._texture.id) gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glPushMatrix() self.transform() # cuadric.begin() self._vertex_list.draw(gl.GL_TRIANGLES) # cuadric.end() # unset gl.glPopMatrix() gl.glPopAttrib() gl.glDisable(self._texture.target)
def write_text(self, text): #gl.glTexEnvf( gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE ) #gl.glEnable( gl.GL_DEPTH_TEST ) gl.glEnable(gl.GL_BLEND) #gl.glEnable( gl.GL_COLOR_MATERIAL ) #gl.glColorMaterial( gl.GL_FRONT_AND_BACK, gl.GL_AMBIENT_AND_DIFFUSE ) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture_id) gl.glColor4f(1, 1, 0, 1) gl.glPushMatrix() gl.glLoadIdentity() gl.glScalef(0.003, 0.003, 0) #gl.glTranslatef(10, 100, 0) gl.glPushMatrix() gl.glListBase(self.base) gl.glCallLists(len(text), gl.GL_UNSIGNED_BYTE, bytes(text, 'utf-8')) #for c in text: # gl.glCallList(self.base + 1 + ord(c)) gl.glPopMatrix() gl.glPopMatrix() gl.glDisable(gl.GL_BLEND) gl.glDisable(gl.GL_TEXTURE_2D)
def draw(self): if len(self.sprite_list) == 0: return if self.vao is None: self.calculate_sprite_buffer() self.texture.use(0) gl.glEnable(gl.GL_BLEND) 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) with self.vao: self.program['Texture'] = self.texture_id self.program['Projection'] = get_projection().flatten() if self.ambient_light is not None and self.light_list is not None: light_data = [] for light in self.light_list: light_data.append(light.x) light_data.append(light.y) self.program['point_light'] = light_data if not self.is_static: self.sprite_data_buf.write(self.sprite_data.tobytes()) self.vao.render(gl.GL_TRIANGLE_STRIP, instances=len(self.sprite_list)) if not self.is_static: self.sprite_data_buf.orphan()
def render(shape: VertexBuffer): """ Render an shape previously created with a ``create`` function. """ # Set color if shape.color is None: raise ValueError("Error: Color parameter not set.") gl.glLoadIdentity() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, shape.vbo_vertex_id) gl.glVertexPointer(2, gl.GL_FLOAT, 0, 0) if shape.line_width: gl.glLineWidth(shape.line_width) 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) gl.glDrawArrays(shape.draw_mode, 0, shape.size)
def set_state(self): """ Ensure that blending is set. """ gl.glPushAttrib(gl.GL_ENABLE_BIT | gl.GL_CURRENT_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def draw(self): """ Draw this list of sprites. """ if self.program is None: # Used in drawing optimization via OpenGL self.program = shader.program(vertex_shader=VERTEX_SHADER, fragment_shader=FRAGMENT_SHADER) if len(self.sprite_list) == 0: return if self.vao is None: self._calculate_sprite_buffer() self._texture.use(0) gl.glEnable(gl.GL_BLEND) 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) with self.vao: self.program['Texture'] = self.texture_id self.program['Projection'] = get_projection().flatten() if not self.is_static: self.sprite_data_buf.write(self.sprite_data.tobytes()) self.vao.render(gl.GL_TRIANGLE_STRIP, instances=len(self.sprite_list)) if not self.is_static: self.sprite_data_buf.orphan()
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 __init__(self): self._width = 800 self._height = 600 super().__init__(width=self._width, height=self._height, resizable=False, vsync=False) self._mouse = Mouse() self._debug = False try: if os.environ['DEBUG'] in ('1', 'TRUE', 'True'): self.push_handlers(pyglet.window.event.WindowEventLogger()) self._debug = True except KeyError: pass glClearColor(0.0, 0.05, 0.2, 1.0) glEnable(GL_BLEND) glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA) self._gc = GraphicsContext() pyglet.clock.schedule_interval(self._main_loop, 1 / 60) self.set_mouse_visible(False)
def init_gl(self): gl.glClearColor(.93, .93, 1, 1) #glColor3f(1, 0, 0) 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)
def init_gl(self): gl.glClearColor(.93, .93, 1, 1) # glColor3f(1, 0, 0) 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)
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 __init__(self, name: str, width: int, height: int, resizable: bool = False, game: BaseGame = None, data: BaseData = None): super(Window, self).__init__(width, height, resizable=resizable) glEnable(GL_DEPTH_TEST) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glClearColor(0, 0, 0, 1) # glEnable(GL_CULL_FACE) self.name = name self.num_frames = 0 self.start_time = datetime.now() self.frame_start_time = datetime.now() self.projection_matrix = identity() if game is None: game = BaseGame() self.game = game self.game.init() if data is None: data = BaseData() self.data = data
def __init__(self, width=600, height=400, display=None): display = self._get_display(display) super().__init__(width=width, height=height, display=display) self.model = None glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def show(self): self.generate(600,400) self.window = pyglet.window.Window(self.image.width,self.image.height) gl.glClearColor(0,0,0,1) gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) self.window.push_handlers(self) pyglet.app.run()
def _InitGLState(self): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) gl.glEnable(gl.GL_TEXTURE_2D) gl.glShadeModel(gl.GL_SMOOTH) gl.glClearColor(0, 0, 0, 1) # Rotated images can have a z-distance of more than one gl.glDepthRangef(0, 2)