def rect(a, b, color=(1.0,1.0,1.0), alpha=1.0): """ Draws a rectangle in the plane spanned by a,b with GL_QUADS :param a: Point a :type a: 2-float tuple :param b: Point b :type b: 2-float tuple :param color: the color in [0..1] range :type color: 3-float tuple :param aa: Anti aliasing Flag :param alpha: the alpha value in [0..1] range """ glDisable(GL_TEXTURE_2D) glBegin(GL_QUADS) glVertex3f(a[0], a[1], 0) glVertex3f(b[0], a[1], 0) glVertex3f(b[0], b[1], 0) glVertex3f(a[0], b[1], 0) glEnd() glEnable(GL_TEXTURE_2D) glColor4f(color+(alpha,))
def set_3d(self): """ Configure OpenGL to draw in 3d. """ width, height = self.get_size() gl.glEnable(gl.GL_DEPTH_TEST) gl.glViewport(0, 0, width, height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.gluPerspective(65.0, width / float(height), 0.1, DIST) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() x, y = self.rotation gl.glRotatef(x, 0, 1, 0) gl.glRotatef(-y, math.cos(math.radians(x)), 0, math.sin(math.radians(x))) x, y, z = self.position gl.glTranslatef(-x, -y, -z) gl.glEnable(gl.GL_LIGHTING) gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, GLfloat4(0.05,0.05,0.05,1.0)) gl.glEnable(gl.GL_COLOR_MATERIAL) gl.glColorMaterial(gl.GL_FRONT, gl.GL_AMBIENT_AND_DIFFUSE) #gl.glLightfv(gl.GL_LIGHT1,gl.GL_SPOT_DIRECTION, GLfloat3(0,0,-1)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, GLfloat4(0.5,0.5,0.5,1.0)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, GLfloat4(1.0,1.0,1.0,1.0)) gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, GLfloat4(0.35,1.0,0.65,0.0)) #gl.glLightfv(gl.GL_LIGHT0,gl.GL_SPECULAR, GLfloat4(1,1,1,1)) gl.glDisable(gl.GL_LIGHT0) gl.glEnable(gl.GL_LIGHT1)
def on_draw(self): """ Render the screen. """ start = time.time() 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, self.vertex_vbo_id) GL.glEnableClientState(GL.GL_VERTEX_ARRAY) GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.color_vbo_id) GL.glEnableClientState(GL.GL_COLOR_ARRAY) GL.glColorPointer(3, GL.GL_FLOAT, 0, 0) offset = 0 for shape in self.shape_list: render_rect_filled(shape, offset) offset += 4 elapsed = time.time() - start print(elapsed)
def circle(pos, radius, color=(1.0,1.0,1.0), alpha=1.0,segments=6): """ Draws a circle with gluDisk :param pos: center of the circle :type pos: 2-float tuple :param radius: radius of the circle :type radius: float :param color: the color in [0..1] range :type color: 3-float tuple :param alpha: the alpha value in [0..1] range :param segments: number of segments :type segments: int """ glDisable(GL_TEXTURE_2D) c = gluNewQuadric() glColor4f(color[0], color[1], color[2], alpha) glPushMatrix() glTranslatef(pos[0], pos[1], 0) gluDisk(c, 0, radius, segments, 1) glPopMatrix() glColor4f(1.0,1.0,1.0,1.0) glEnable(GL_TEXTURE_2D)
def draw(self): if self._render_object: pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT | pgl.GL_DEPTH_BUFFER_BIT) if self._overlay: pgl.glDisable(pgl.GL_DEPTH_TEST) self._render_object.draw() pgl.glPopAttrib()
def poll(dt): out = next(itr, False) if out is False: if args.pause: label.text = "Done. ('q' to quit)" else: pyglet.app.exit() elif out is not None: name, buf = out real_dt = time.time() - last_time[0] last_time[0] = time.time() if buf.dtype == np.uint8: fmt = gl.GL_UNSIGNED_BYTE elif buf.dtype == np.uint16: fmt = gl.GL_UNSIGNED_SHORT else: label.text = 'Unsupported format: ' + buf.dtype return h, w, ch = buf.shape gl.glEnable(tex.target) gl.glBindTexture(tex.target, tex.id) gl.glTexImage2D(tex.target, 0, gl.GL_RGB8, w, h, 0, gl.GL_RGBA, fmt, buf.tostring()) gl.glDisable(tex.target) label.text = '%s (%g fps)' % (name, 1./real_dt) else: label.text += '.'
def create_window(self, _iScr=0, _title="", _dx=0, _dy=0, _left=0, _top=0, _scale=1.0, _isScrOvl=False, _iScrGUI=0, _offset=(0,0)): """ If the renderer was initialized, create a window instance and store it in the internal window list. For parameters, see Window class. """ if self.isReady: self.winList.append(Window(self, _iScr, _title, _dx, _dy, _left, _top, _scale, _isScrOvl, _iScrGUI, _offset)) ''' if len(self.winList) == 1: # Is the first window, set some general OpenGL properties # ''' GL.glClearColor(0., 0., 0., 0.) GL.glColor3f(1., 1., 1.) GL.glDisable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) ''' GL.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) GL.glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) GL.glShadeModel(GL_FLAT) # GL_FLAT or GL_SMOOTH GL.glEnable(GL_POINT_SMOOTH) ''' return self.winList[-1] else: return None
def draw(self): from miru.context import context gl.glEnable(gl.GL_LINE_STIPPLE) gl.glLineStipple(1, 0x51315) gl.glColor4f(*self.color) for c in self.metaCamera.cameras: vp = c.projection x = vp.x == 0 and 1 or vp.x width = vp.x == 0 and vp.width - 1 or vp.width width = (vp.x + vp.width) >= context.window.width and width - 1 or width y = vp.y == 0 and 1 or vp.y height = vp.y == 0 and vp.height - 1 or vp.height height = (vp.y + vp.height) >= context.window.height and height - 1 or height gl.glBegin(gl.GL_LINE_LOOP) gl.glVertex2f(x, y) gl.glVertex2f(x, y + height) gl.glVertex2f(x + width, y + height) gl.glVertex2f(x + width, y) gl.glEnd() gl.glDisable(gl.GL_LINE_LOOP) gl.glColor4f(1,1,1,1)
def on_draw(self): self.window.clear() gl.glMatrixMode(gl.GL_PROJECTION) gl.glPushMatrix() gl.glLoadIdentity() self.camera() gl.glEnable(self.grass.target) gl.glEnable(gl.GL_BLEND) gl.glBindTexture(self.grass.target, self.grass.id) W = 10000. graphics.draw(4, gl.GL_QUADS, ('v2f', (-W, -W, W, -W, W, W, -W, W)), ('t2f', (0., 0., W*5., 0., W*5., W*5., 0., W*5.)) ) gl.glDisable(self.grass.target) for lane in self.lanes: self.draw_lane_surface(lane) for lane in self.lanes: self.draw_lane_lines(lane) for obj in self.objects: self.draw_object(obj) for car in self.cars: if car!=self.main_car and car not in self.visible_cars: self.draw_car(self.anim_x[car], car.color) if self.heat is not None: self.draw_heatmap() for car in self.cars: if car==self.main_car or car in self.visible_cars: self.draw_car(self.anim_x[car], car.color) gl.glPopMatrix() if isinstance(self.main_car, Car): self.label.text = 'Speed: %.2f'%self.anim_x[self.main_car][3] self.label.draw() if self.output is not None: pyglet.image.get_buffer_manager().get_color_buffer().save(self.output.format(self.frame))
def draw(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 setup(self): # One-time GL setup gl.glClearColor(1, 1, 1, 0) gl.glColor3f(1, 0, 0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glDisable(gl.GL_LIGHTING)
def unset_state(self): """ Disables the scissor test """ if not self.was_scissor_enabled: gl.glDisable(gl.GL_SCISSOR_TEST) gl.glPopAttrib()
def enable_states(gl_states): """Context Manager that calls glEnable and glDisable on a list of gl states.""" for state in gl_states: gl.glEnable(state) yield for state in gl_states: gl.glDisable(state)
def _set_backface_culling(self, value): self._backface_culling = value if self._backface_culling: gl.glCullFace(gl.GL_BACK) gl.glEnable(gl.GL_CULL_FACE) else: gl.glDisable(gl.GL_CULL_FACE)
def blit_buffer(self, framebuffer, parent_width, parent_height, **kwargs): """Draw the texture into the parent scene .. warning: This method's arguments are not part of the API yet and may change at any time. """ gl.glViewport(0, 0, parent_width, parent_height) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glBindTexture(gl.GL_TEXTURE_2D, framebuffer.texture_id) gl.glEnable(gl.GL_TEXTURE_2D) gl.glColor4fv((gl.GLfloat * 4)(*self.color + (self.opacity, ))) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE_MINUS_SRC_ALPHA) # premultipl. gl.glBegin(gl.GL_TRIANGLE_STRIP) gl.glTexCoord2f(0, 0) gl.glVertex2i(0, 0) gl.glTexCoord2f(0, parent_height) gl.glVertex2i(0, parent_height) gl.glTexCoord2f(parent_width, 0) gl.glVertex2i(parent_width, 0) gl.glTexCoord2f(parent_width, parent_height) gl.glVertex2i(parent_width, parent_height) gl.glEnd() gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glDisable(gl.GL_TEXTURE_2D) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glViewport(0, 0, parent_width, parent_height)
def update_display(verts,tex_coords,texture=bird_texture): gl.glClearColor(0.2, 0.4, 0.5, 1.0) gl.glEnable(texture.target) gl.glBindTexture(texture.target, texture.id) gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_ALPHA_TEST) gl.glAlphaFunc (gl.GL_GREATER, .1) #gl.glEnable(gl.GL_BLEND) #gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) n=len(verts[:]) #TODO verts._buffer.ctypes.data is awkward gl.glVertexPointer(3, vert_dtype.gl, 0, verts[:].ctypes.data) gl.glTexCoordPointer(3, tex_dtype.gl, 0, tex_coords[:].ctypes.data) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, n) #unset state gl.glPopAttrib() gl.glDisable(texture.target)
def display(self, mode_2d=False): with self.lock: glPushMatrix() glTranslatef(self.offset_x, self.offset_y, 0) glEnableClientState(GL_VERTEX_ARRAY) has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) if self.display_travels: self._display_travels(has_vbo) glEnable(GL_LIGHTING) glEnableClientState(GL_NORMAL_ARRAY) glEnableClientState(GL_COLOR_ARRAY) glMaterialfv(GL_FRONT, GL_SPECULAR, vec(1, 1, 1, 1)) glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, vec(0, 0, 0, 0)) glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50) glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE) self._display_movements(has_vbo) glDisable(GL_LIGHTING) glDisableClientState(GL_COLOR_ARRAY) glDisableClientState(GL_VERTEX_ARRAY) glDisableClientState(GL_NORMAL_ARRAY) glPopMatrix()
def after_draw(self, camera): """Called by CocosNode when the texture is already grabbed. The FrameBuffer will be unbound and the texture will be drawn :Parameters: `camera` : `Camera` The target's camera object. """ # capture after drawing self.grabber.after_render(self.texture) # after unbinding # set a 3d projection self._set_3d_projection() # and center the camera camera.locate(force=True) # blit gl.glEnable(self.texture.target) gl.glBindTexture(self.texture.target, self.texture.id) gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT) self._blit() gl.glPopAttrib() gl.glDisable(self.texture.target)
def display(self, mode_2d=False): glEnable(GL_LINE_SMOOTH) orig_linewidth = (GLfloat)() glGetFloatv(GL_LINE_WIDTH, orig_linewidth) glLineWidth(3.0) glCallList(self.display_list) glLineWidth(orig_linewidth) glDisable(GL_LINE_SMOOTH)
def postDraw(self): """Called right after this layer draws; should revert any changes from preDraw().""" self._layerProjectLocalToScreenUndo() if self._scissorBox is not None: gl.glDisable(gl.GL_SCISSOR_TEST) frameCachedProperty.clear(self)
def draw(self, win=None): #set the window to draw to if win==None: win=self.win if win.winType=='pyglet': win.winHandle.switch_to() #work out next default depth if self.depth==0: thisDepth = self.win._defDepth self.win._defDepth += _depthIncrements[self.win.winType] else: thisDepth=self.depth GL.glPushMatrix() #scale and rotate prevScale = self.win.setScale(self._winScale) GL.glTranslatef(self._posRendered[0],self._posRendered[1],thisDepth)#NB depth is set already GL.glRotatef(self.ori,0.0,0.0,1.0) self.win.setScale('pix',None, prevScale) if self._useShaders: #then rgb needs to be set as glColor #setup color desiredRGB = (self.rgb*self.contrast+1)/2.0#RGB in range 0:1 and scaled for contrast if numpy.any(desiredRGB**2.0>1.0): desiredRGB=[0.6,0.6,0.4] GL.glColor4f(desiredRGB[0],desiredRGB[1],desiredRGB[2], self.opacity) else: #color is set in texture, so set glColor to white GL.glColor4f(1,1,1,1) GL.glDisable(GL.GL_DEPTH_TEST) #should text have a depth or just on top? #update list if necss and then call it if self.win.winType=='pyglet': #and align based on x anchor if self.alignHoriz=='right': GL.glTranslatef(-self.width,0,0)#NB depth is set already if self.alignHoriz in ['center', 'centre']: GL.glTranslatef(-self.width/2,0,0)#NB depth is set already #unbind the mask texture regardless GL.glActiveTexture(GL.GL_TEXTURE1) GL.glEnable(GL.GL_TEXTURE_2D) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) #unbind the main texture GL.glActiveTexture(GL.GL_TEXTURE0) GL.glEnable(GL.GL_TEXTURE_2D) #then allow pyglet to bind and use texture during drawing self.glyphStr.draw() GL.glDisable(GL.GL_TEXTURE_2D) else: #for pygame we should (and can) use a drawing list if self.needUpdate: self._updateList() GL.glCallList(self._listID) GL.glEnable(GL.GL_DEPTH_TEST) # Enables Depth Testing GL.glPopMatrix()
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 update_flags(self): if self.view['wireframe']: gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE) else: gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_FILL) if self.view['cull']: gl.glEnable(gl.GL_CULL_FACE) else: gl.glDisable(gl.GL_CULL_FACE)
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 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 unset_state(self): ''' Disables the scissor test ''' if self._scale != 1.0: gl.glPopMatrix(gl.GL_MODELVIEW_MATRIX) if not self.was_scissor_enabled: gl.glDisable(gl.GL_SCISSOR_TEST) gl.glPopAttrib()
def set_2d(self, size): """Configure OpenGL to draw in 2d.""" width, height = size GL.glDisable(GL.GL_DEPTH_TEST) GL.glViewport(0, 0, width, height) GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GL.glOrtho(0, width, 0, height, -1, 1) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity()
def on_key_press(self, symbol, modifiers): if symbol == pyglet.window.key.F and (modifiers & pyglet.window.key.MOD_ACCEL): director.window.set_fullscreen(not director.window.fullscreen) return True elif symbol == pyglet.window.key.P and (modifiers & pyglet.window.key.MOD_ACCEL): import cocos.scenes.pause as pause pause_sc = pause.get_pause_scene() if pause: director.push(pause_sc) return True elif symbol == pyglet.window.key.W and (modifiers & pyglet.window.key.MOD_ACCEL): # import wired if not self.wired: gl.glDisable(gl.GL_TEXTURE_2D) gl.glPolygonMode(gl.GL_FRONT, gl.GL_LINE) gl.glPolygonMode(gl.GL_BACK, gl.GL_LINE) # wired.wired.install() # wired.wired.uset4F('color', 1.0, 1.0, 1.0, 1.0 ) self.wired = True else: gl.glEnable(gl.GL_TEXTURE_2D) gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL) gl.glPolygonMode(gl.GL_BACK, gl.GL_FILL) self.wired = False # wired.wired.uninstall() return True elif symbol == pyglet.window.key.X and (modifiers & pyglet.window.key.MOD_ACCEL): director.show_FPS = not director.show_FPS return True elif symbol == pyglet.window.key.I and (modifiers & pyglet.window.key.MOD_ACCEL): from .layer import PythonInterpreterLayer if not director.show_interpreter: if director.python_interpreter is None: director.python_interpreter = cocos.scene.Scene(PythonInterpreterLayer()) director.python_interpreter.enable_handlers(True) director.python_interpreter.on_enter() director.show_interpreter = True else: director.python_interpreter.on_exit() director.show_interpreter = False return True elif symbol == pyglet.window.key.S and (modifiers & pyglet.window.key.MOD_ACCEL): import time pyglet.image.get_buffer_manager().get_color_buffer().save('screenshot-%d.png' % (int(time.time()))) return True if symbol == pyglet.window.key.ESCAPE: director.pop() return True
def set_2d(self): """ Configure OpenGL to draw in 2d. """ width, height = self.get_size() glDisable(GL_DEPTH_TEST) glViewport(0, 0, width, height) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0, width, 0, height, -1, 1) glMatrixMode(GL_MODELVIEW) glLoadIdentity()
def set_alpha_blending(self, on=True): """ Enables/Disables alpha blending in OpenGL using the GL_ONE_MINUS_SRC_ALPHA algorithm. On by default. """ if on: gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) else: gl.glDisable(gl.GL_BLEND)
def __init__(self, *args, **kwargs): super(GameWindow, self).__init__(*args, **kwargs) gl.glClearColor(0.4, 0.4, 0.4, 1.0) # gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # gl.glEnable(gl.GL_BLEND) # gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glDisable(gl.GL_DEPTH_TEST) gl.glDisable(gl.GL_LINE_SMOOTH) clock.schedule_interval(lambda dt: self.dispatch_event('on_update', dt), 0.01) self.x, self.y = 0, 0 self._translation_acc_x, self._translation_acc_y = 0.0, 0.0
def set_2d(self): width, height = self.get_size() glDisable(GL_CULL_FACE) glDisable(GL_DEPTH_TEST) viewport = self.get_viewport_size() glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1])) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0, max(1, width), 0, max(1, height), -1, 1) glMatrixMode(GL_MODELVIEW) glLoadIdentity()
def _startOfFlip(self): """Custom :py:class:`~Rift._startOfFlip` for HMD rendering. This finalizes the HMD texture before diverting drawing operations back to the on-screen window. This allows :py:class:`~Rift.flip` to swap the on-screen and HMD buffers when called. This function always returns `True`. Returns ------- True """ # nop if we are still setting up the window if not hasattr(self, '_eyeBuffers'): return True # direct draw being used, don't do FBO blit if self._directDraw: return True # Switch off multi-sampling # GL.glDisable(GL.GL_MULTISAMPLE) oldColor = self.color self.setColor((-1, -1, -1)) self.setBuffer('back', clear=True) self._prepareFBOrender() # need blit the framebuffer object to the actual back buffer # unbind the framebuffer as the render target GL.glDisable(GL.GL_BLEND) stencilOn = self.stencilTest self.stencilTest = False # before flipping need to copy the renderBuffer to the # frameBuffer GL.glActiveTexture(GL.GL_TEXTURE0) GL.glEnable(GL.GL_TEXTURE_2D) GL.glColor3f(1.0, 1.0, 1.0) # glColor multiplies with texture GL.glColorMask(True, True, True, True) # blit the textures to the back buffer for eye in ('left', 'right'): self._blitEyeBuffer(eye) GL.glEnable(GL.GL_BLEND) self._finishFBOrender() self.stencilTest = stencilOn self.setColor(oldColor) # This always returns True return True
def on_key_press(self, symbol, modifiers): if symbol == pyglet.window.key.F and (modifiers & pyglet.window.key.MOD_ACCEL): director.window.set_fullscreen(not director.window.fullscreen) return True elif symbol == pyglet.window.key.P and (modifiers & pyglet.window.key.MOD_ACCEL): import cocos.scenes.pause as pause pause_sc = pause.get_pause_scene() if pause: director.push(pause_sc) return True elif symbol == pyglet.window.key.W and (modifiers & pyglet.window.key.MOD_ACCEL): # import wired if not self.wired: gl.glDisable(gl.GL_TEXTURE_2D) gl.glPolygonMode(gl.GL_FRONT, gl.GL_LINE) gl.glPolygonMode(gl.GL_BACK, gl.GL_LINE) # wired.wired.install() # wired.wired.uset4F('color', 1.0, 1.0, 1.0, 1.0 ) self.wired = True else: gl.glEnable(gl.GL_TEXTURE_2D) gl.glPolygonMode(gl.GL_FRONT, gl.GL_FILL) gl.glPolygonMode(gl.GL_BACK, gl.GL_FILL) self.wired = False # wired.wired.uninstall() return True elif symbol == pyglet.window.key.X and (modifiers & pyglet.window.key.MOD_ACCEL): director.show_FPS = not director.show_FPS return True elif symbol == pyglet.window.key.I and (modifiers & pyglet.window.key.MOD_ACCEL): from .layer import PythonInterpreterLayer if not director.show_interpreter: if director.python_interpreter is None: director.python_interpreter = cocos.scene.Scene(PythonInterpreterLayer()) director.python_interpreter.on_enter() director.show_interpreter = True else: director.python_interpreter.on_exit() director.show_interpreter = False return True elif symbol == pyglet.window.key.S and (modifiers & pyglet.window.key.MOD_ACCEL): import time pyglet.image.get_buffer_manager().get_color_buffer().save('screenshot-%d.png' % (int(time.time()))) return True if symbol == pyglet.window.key.ESCAPE: director.pop() return True
def on_draw(self): self.clear() self.camera.update() self.border.update() gl.glEnable(gl.GL_DEPTH_TEST) self.axis.update() self.terrain.update() for model in self.models: model.update(self.step) gl.glDisable(gl.GL_DEPTH_TEST) gl.glTranslatef(self.width / 2 - 160, self.height / -2 + 20, 0) self.clock.draw()
def render_mesh(self, segment: bool, enable_leds: bool): self.mesh.render(segment=segment) if enable_leds and self.kind == MapFormat1Constants.KIND_DUCKIEBOT: # attrs = # gl.glPushAttrib(gl.GL_ALL_ATTRIB_BITS) s_main = 0.01 # 1 cm sphere # LIGHT_MULT_MAIN = 10 s_halo = 0.04 height = 0.05 positions = { "front_left": [0.1, -0.05, height], "front_right": [0.1, +0.05, height], "center": [0.1, +0.0, height], "back_left": [-0.1, -0.05, height], "back_right": [-0.1, +0.05, height], } if isinstance(self, DuckiebotObj): colors = self.leds_color else: colors = { "center": (0, 0, 1), "front_left": (0, 0, 1), "front_right": (0, 0, 1), "back_left": (0, 0, 1), "back_right": (0, 0, 1), } for light_name, (px, py, pz) in positions.items(): color = np.clip(colors[light_name], 0, +1) color_intensity = float(np.mean(color)) gl.glPushMatrix() gl.glTranslatef(px, pz, py) gl.glEnable(gl.GL_BLEND) # gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) sphere = gluNewQuadric() gl.glColor4f(color[0], color[1], color[2], 1.0) gluSphere(sphere, s_main, 10, 10) gl.glColor4f(color[0], color[1], color[2], 0.2) s_halo_effective = color_intensity * s_halo gluSphere(sphere, s_halo_effective, 10, 10) gl.glColor4f(1.0, 1.0, 1.0, 1.0) gl.glBlendFunc(gl.GL_ONE, gl.GL_ZERO) gl.glDisable(gl.GL_BLEND) gl.glPopMatrix()
def draw_fallback(self): """Called instead of :meth:`draw` when quads are used instead of Point Sprite. """ self.make_delta_pos_to_vertex() self.update_vertexs_from_pos() self.update_per_vertex_colors() gl.glPushMatrix() self.transform() # color preserve - at least intel 945G needs that gl.glPushAttrib(gl.GL_CURRENT_BIT) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture.id) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) vertexs_ptr = PointerToNumpy(self.vertexs) gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertexs_ptr) gl.glEnableClientState(gl.GL_COLOR_ARRAY) color_ptr = PointerToNumpy(self.per_vertex_colors) # gl.glColorPointer(4, gl.GL_UNSIGNED_BYTE, 0, color_ptr) gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) tex_coord_ptr = PointerToNumpy(self.tex_coords) gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, tex_coord_ptr) gl.glPushAttrib(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_BLEND) if self.blend_additive: gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE) else: gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDrawArrays(gl.GL_QUADS, 0, len(self.vertexs) * 4) # un -blend gl.glPopAttrib() # color restore gl.glPopAttrib() # disable states gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisable(gl.GL_TEXTURE_2D) gl.glPopMatrix()
def _text_glyphs_gl(self): if not self._text_dlist: dl_index = glGenLists(1) glNewList(dl_index, GL_COMPILE) # stime=getTime() # self._text_box._te_start_gl() ### glActiveTexture(GL_TEXTURE0) glEnable(GL_TEXTURE_2D) glBindTexture( GL_TEXTURE_2D, self._text_box._current_glfont.atlas.texid) glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE) glTranslatef(self._position[0], -self._position[1], 0) glPushMatrix() ### getLineInfoByIndex = self._text_document.getLineInfoByIndex active_text_style_dlist = self._current_font_display_lists.get cell_width, cell_height = self._cell_size num_cols, num_rows = self._shape line_spacing = self._text_box._getPixelTextLineSpacing() line_count = self.getRowCountWithText() glColor4f(*self._text_box._toRGBA(self._font_color)) for r in range(line_count): cline, line_length, line_display_list, line_ords = getLineInfoByIndex( r) if line_display_list[0] == 0: line_display_list[0:line_length] = [ active_text_style_dlist(c) for c in line_ords] glTranslatef(cline._trans_left * cell_width, - int(line_spacing/2.0 + cline._trans_top * cell_height), 0) glCallLists(line_length, GL_UNSIGNED_INT, line_display_list[0:line_length].ctypes) cline._trans_left = 0 glTranslatef(-line_length * cell_width - cline._trans_left * cell_width, - cell_height + int(line_spacing/2.0 + cline._trans_top * cell_height), 0) ### glPopMatrix() glBindTexture(GL_TEXTURE_2D, 0) glDisable(GL_TEXTURE_2D) glEndList() self._text_dlist = dl_index glCallList(self._text_dlist)
def draw_transition(self, percentage_done): if self.destination is None: self.source.alpha = 1 - percentage_done self.source.render() elif self.source is None: self.destination.alpha = percentage_done self.destination.render() elif self.source and self.destination: gl.glDisable(gl.GL_BLEND) self.source.render() gl.glEnable(gl.GL_BLEND) self.destination.alpha = percentage_done self.destination.render()
def set_2d(self): """ Configure Opengl.GL to draw in 2d. """ width, height = self.get_size() gl.glDisable(gl.GL_DEPTH_TEST) viewport = self.get_viewport_size() gl.glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1])) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.glOrtho(0, max(1, width), 0, max(1, height), -1, 1) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity()
def DrawRectangle(rect, color): '''Draw a rectangle''' vertarray = VertsForRectangle(rect) LineIndicies = [0, 1, 1, 2, 2, 3, 3, 0] gl.glDisable(gl.GL_TEXTURE_2D) pyglet.gl.glColor4f(color[0], color[1], color[2], color[3]) pyglet.graphics.draw_indexed( len(vertarray) / 3, gl.GL_LINES, LineIndicies, ('v3f', vertarray)) pyglet.gl.glColor4f(1.0, 1.0, 1.0, 1.0)
def render(self): for idx, vlist in enumerate(self.vlists): texture = self.textures[idx] if texture: glEnable(GL_TEXTURE_2D) glBindTexture(texture.target, texture.id) else: glDisable(GL_TEXTURE_2D) vlist.draw(GL_TRIANGLES) glDisable(GL_TEXTURE_2D)
def render_img(img, x, y, w, h): img_data = pyglet.image.ImageData( img.shape[1], img.shape[0], 'RGB', img.tobytes()) tex = img_data.get_texture() gl.glEnable(gl.GL_TEXTURE_2D) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glBindTexture(gl.GL_TEXTURE_2D, tex.id) pyglet.graphics.draw_indexed(4, gl.GL_TRIANGLE_STRIP, [0, 1, 2, 0, 2, 3], ('v2f', (x, y+h, x+w, y+h, x+w, y, x, y)), ('t3f', tex.tex_coords), ) gl.glDisable(gl.GL_TEXTURE_2D)
def _setup_2d(self): w, h = self.get_size() gl.glDisable(gl.GL_DEPTH_TEST) viewport = self.get_viewport_size() gl.glViewport(0, 0, max(1, viewport[0]), max(1, viewport[1])) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.glOrtho(0, max(1, w), 0, max(1, h), -1, 1) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity()
def world_projection(self): """ Project the world. """ gl.glDisable(gl.GL_DEPTH_TEST) gl.glViewport(0, 0, self.win.width, self.win.height) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() width_ratio = self.win.width / self.win.height gl.gluOrtho2D(-self.zoom * width_ratio, self.zoom * width_ratio, -self.zoom, self.zoom) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity()
def quad_aligned(x, y, w, h, color): quad_data = pyglet.graphics.vertex_list_indexed( 4, [0, 1, 2, 2, 3, 0], ('v2i', (x, y, x + w, y, x + w, y + h, x, y + h)), ('c4B', color * 4)) gl.glEnable(gl.GL_BLEND) quad_data.draw(pyglet.gl.GL_TRIANGLES) gl.glDisable(gl.GL_BLEND)
def disable(self, *args): """ Disable one or more context flags:: # Single flag ctx.disable(ctx.BLEND) # Multiple flags ctx.disable(ctx.DEPTH_TEST, ctx.CULL_FACE) """ self._flags -= set(args) for flag in args: gl.glDisable(flag)
def draw(self, uniforms, entity, models, textures=(), color=(1.0, 1.0, 1.0), *args, **kwargs): glUseProgram(self) glDisable(GL_DEPTH_TEST) # Draw objects once as invisible to set stencil values. glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE) # Don't write any color values to color buffer. glStencilMask(0xFF) # Enable writing. model = models[entity.model] model.positions.enable() model.indices.enable() glUniformMatrix4fv( self.uniforms[b'perspective'], 1, GL_TRUE, uniforms.get(b'perspective').ctypes.data_as(POINTER(GLfloat)) ) glUniformMatrix4fv( self.uniforms[b'view'], 1, GL_TRUE, uniforms.get(b'view').ctypes.data_as(POINTER(GLfloat)) ) glUniform3f(self.uniforms[b'color'], *color) glUniformMatrix4fv( self.uniforms[b'transformation'], 1, GL_TRUE, entity.get_transformation_matrix().ctypes.data_as(POINTER(GLfloat)) ) model.draw() # Draw again with larger model. glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glStencilFunc(GL_NOTEQUAL, 1, 0xFF) # Update with 1's where the objects are rendered. glStencilMask(0x00) # Value that AND's the value written to buffer. 0x00 basically disables writing to stencil. glUniformMatrix4fv( self.uniforms[b'transformation'], 1, GL_TRUE, create_transformation_matrix( *entity.location, *entity.rotation, *(entity.scale + 0.05) ).ctypes.data_as(POINTER(GLfloat)) ) model.draw() glBindBuffer(GL_ARRAY_BUFFER, 0) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) glDisableVertexAttribArray(0) glEnable(GL_DEPTH_TEST) glStencilMask(0xFF)
def enable_only(self, *args): """ Enable only some flags. This will disable all other flags. This is a simple way to ensure that context flag states are not lingering from other sections of your code base:: # Ensure all flags are disabled (enable no flags) ctx.enable_only() # Make sure only blending is enabled ctx.enable_only(ctx.BLEND) # Make sure only depth test and culling is enabled ctx.enable_only(ctx.DEPTH_TEST, ctx.CULL_FACE) """ self._flags = set(args) if self.BLEND in self._flags: gl.glEnable(self.BLEND) else: gl.glDisable(self.BLEND) if self.DEPTH_TEST in self._flags: gl.glEnable(self.DEPTH_TEST) else: gl.glDisable(self.DEPTH_TEST) if self.CULL_FACE in self._flags: gl.glEnable(self.CULL_FACE) else: gl.glDisable(self.CULL_FACE) if self.PROGRAM_POINT_SIZE in self._flags: gl.glEnable(self.PROGRAM_POINT_SIZE) else: gl.glDisable(self.PROGRAM_POINT_SIZE)
def DrawTriangles(verts, Triangles): LineIndicies = LineIndiciesFromTri(Triangles) zCoords = numpy.ones((len(verts), 1), dtype=verts.dtype) Points = numpy.hstack((verts, zCoords)) FlatPoints = Points.ravel().tolist() vertarray = (gl.GLfloat * len(FlatPoints))(*FlatPoints) gl.glDisable(gl.GL_TEXTURE_2D) pyglet.gl.glColor4f(1.0, 0, 0, 1.0) pyglet.graphics.draw_indexed( len(vertarray) // 3, gl.GL_LINES, LineIndicies, ('v3f', vertarray)) pyglet.gl.glColor4f(1.0, 1.0, 1.0, 1.0)
def multi_draw(*args, **kwargs): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glClearColor(0, 0, 0, 0) gl.glColor4f(1, 1, 1, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) if not buffers: buffers.append(image.get_buffer_manager()) x, y, w, h = buffers[0].get_viewport() #Draw lowres version gl.glViewport(0, 0, 256, 256) func(*args, **kwargs) texes.append(buffers[0].get_color_buffer().texture) if len(texes) > num_texes: texes.pop(0) #Lay down copies of lowres version gl.glViewport(x, y, w, h) gl.glClear(gl.GL_COLOR_BUFFER_BIT) if texes: alphas = range(1, len(texes) + 1) alphas = [float(f) / sum(alphas) for f in alphas] for tex, alpha in zip(texes, alphas): gl.glBindTexture(tex.target, tex.id) gl.glEnable(gl.GL_TEXTURE_2D) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glColor4f(1, 1, 1, alpha) gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0, 0) gl.glVertex3f(0, 0, -.5) gl.glTexCoord2f(1, 0) gl.glVertex3f(w, 0, -.5) gl.glTexCoord2f(1, 1) gl.glVertex3f(w, h, -.5) gl.glTexCoord2f(0, 1) gl.glVertex3f(0, h, -.5) gl.glEnd() gl.glDisable(gl.GL_TEXTURE_2D) #Draw real thing gl.glColor4f(1, 1, 1, 1) func(*args, **kwargs)
def init_model(self, scene): """ Add the pyramid normals and vertices to the View :param scene: The view to render the model to. :type scene: pyglet_helper.objects.View """ # Note that this model is also used by arrow! scene.pyramid_model.gl_compile_begin() vertices = [[0, .5, .5], [0, -.5, .5], [0, -.5, -.5], [0, .5, -.5], [1, 0, 0]] triangle_indices = [0, 0, 0] * 6 triangle_indices[0] = [3, 0, 4] # top triangle_indices[1] = [1, 2, 4] # bottom triangle_indices[2] = [0, 1, 4] # front triangle_indices[3] = [3, 4, 2] # back triangle_indices[4] = [0, 3, 2] # left (base) 1 triangle_indices[5] = [0, 2, 1] # left (base) 2 normals = [[1, 2, 0], [1, -2, 0], [1, 0, 2], [1, 0, -2], [-1, 0, 0], [-1, 0, 0]] gl.glEnable(gl.GL_CULL_FACE) gl.glBegin(gl.GL_TRIANGLES) # Inside for face in range(0, 6): gl.glNormal3f(-normals[face][0], -normals[face][1], -normals[face][2]) for vertex in range(0, 3): #print triangle_indices[face] #print vertices[triangle_indices[face]][2 - vertex] vert = [gl.GLfloat(i) for i in vertices[triangle_indices[face][2 - vertex]]] gl.glVertex3f(*vert) # Outside for face in range(0, 6): gl.glNormal3fv(*[gl.GLfloat(i) for i in normals[face]]) for vertex in range(0, 3): gl.glVertex3f(*[gl.GLfloat(i) for i in vertices[triangle_indices[ face][vertex]]]) gl.glEnd() gl.glDisable(gl.GL_CULL_FACE) self.compiled = True scene.pyramid_model.gl_compile_end()
def draw_texture(texture): gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) gl.glTranslatef(50, 50, 0) gl.glScalef(7, 7, 1) pyglet.graphics.draw_indexed( 4, gl.GL_TRIANGLES, [0, 1, 2, 2, 1, 3], ('v2i', (0, 0, BUF_WIDTH, 0, 0, BUF_HEIGHT, BUF_WIDTH, BUF_HEIGHT)), ('t2f', (0, 0, 1, 0, 0, 1, 1, 1))) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) gl.glDisable(gl.GL_TEXTURE_2D)
def draw_question(self): if not self.parent.visible: return gl.glDisable(gl.GL_TEXTURE_2D) x, y = self.x, self.y draw_border(x, y, self.width, self.height) self.questionLabel.draw() pressed = self.player.mouse.left over = self.overBox for id, answer in enumerate(self.answers): state = id == over and pressed draw_border(answer.x + 6, answer.y + 2, self.width - 12, answer.content_height + 4, state) answer.draw()
def multi_draw(*args, **kwargs): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glClearColor(0, 0, 0, 0) gl.glColor4f(1, 1, 1, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) if not buffers: buffers.append(image.get_buffer_manager()) x, y, w, h = buffers[0].get_viewport() #Draw lowres version gl.glViewport(0, 0, 256, 256) func(*args, **kwargs) ctex[0] = buffers[0].get_color_buffer().texture #Lay down copies of lowres version gl.glViewport(x, y, w, h) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glBindTexture(ctex[0].target, ctex[0].id) gl.glEnable(gl.GL_TEXTURE_2D) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) if not disp_list: disp_list.append(gl.glGenLists(1)) gl.glNewList(disp_list[0], gl.GL_COMPILE) for u in range(-3, 4, 3): for v in range(-3, 4, 3): gl.glColor4f(1, 1, 1, (20.0 - u**2 - v**2) / 72) gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0, 0) gl.glVertex3f(u, v, -.5) gl.glTexCoord2f(1, 0) gl.glVertex3f(u + w, v, -.5) gl.glTexCoord2f(1, 1) gl.glVertex3f(u + w, v + h, -.5) gl.glTexCoord2f(0, 1) gl.glVertex3f(u, v + h, -.5) gl.glEnd() gl.glEndList() gl.glCallList(disp_list[0]) gl.glDisable(gl.GL_TEXTURE_2D) #Draw real thing gl.glColor4f(1, 1, 1, 1) func(*args, **kwargs)
def draw_translucent_fancy(self): gl.glDepthMask(gl.GL_FALSE) gl.glFrontFace(gl.GL_CW) gl.glEnable(gl.GL_BLEND) for render_chunk in self.sorted_chunks: render_chunk.draw_translucent(gl.GL_TRIANGLES) gl.glFrontFace(gl.GL_CCW) for render_chunk in self.sorted_chunks: render_chunk.draw_translucent(gl.GL_TRIANGLES) gl.glDisable(gl.GL_BLEND) gl.glDepthMask(gl.GL_TRUE)
def on_draw(): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() gl.gluOrtho2D(0, 1, 1, 0) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() gl.glViewport(0, 0, self.width, self.height) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(self.texture.target, self.texture.id) self.draw(0, 0, 1, 1) gl.glDisable(gl.GL_TEXTURE_2D)
def point_sprites_available(): """returns a bool telling if point sprites are available For development and diagonostic cocos.particle.forced_point_sprites could be set to force the desired return value """ if forced_point_sprites is not None: return forced_point_sprites have_point_sprites = True try: gl.glEnable(gl.GL_POINT_SPRITE) gl.glDisable(gl.GL_POINT_SPRITE) except: have_point_sprites = False return have_point_sprites
def init_ortho(self): # disable shaders gl.glUseProgram(0) gl.glDisable(gl.GL_LIGHTING) # store the projection matrix to restore later gl.glMatrixMode(gl.GL_PROJECTION) # load orthographic projection matrix gl.glLoadIdentity() gl.glOrtho(0, self.width, 0, self.height, -1, 500) # reset modelview gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity()