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 draw(self, state = [0,0,0]): gl.glEnable (gl.GL_LINE_SMOOTH); gl.glHint (gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glLoadIdentity() gl.glLineWidth(1) gl.glColor3f(.7,.7,.7) draw_rect((-.5,0), (.5,-.01)) draw_rect((-.01,0),(.01,1)) gl.glTranslatef(0,self.r_roller,0); gl.glPushMatrix(); gl.glTranslatef(state[0]*self.r_roller, 0, 0) gl.glColor3f(0,0,0) gl.glLineWidth(3) # gl.glPushMatrix() gl.glRotatef(-R2D*state[0],0,0,1) draw_mass_center(self.r_roller, (0,0)) # gl.glPopMatrix() gl.glRotatef(-R2D*state[1], 0, 0, 1) gl.glTranslatef(0,self.r_roller,0) gl.glPushMatrix() gl.glRotatef(R2D*(state[1]+state[0]),0,0,1) gl.glPushAttrib(gl.GL_ENABLE_BIT); gl.glColor3f(.7,.2,.2) gl.glLineStipple(1, 0xF00F) # [1] gl.glEnable(gl.GL_LINE_STIPPLE) draw_line((0,0),(0,1)) gl.glPopAttrib() gl.glPopMatrix() gl.glTranslatef(-state[1] * self.r_roller,0,0) gl.glColor3f(0,0,0) draw_rect( (-self.l_board/2,0), (self.l_board/2,.02)) gl.glColor3f(.5,.5,.5) draw_rect((-.01,0), (.01,self.h_body)) gl.glPushMatrix() gl.glTranslatef(0, self.h_body, 0) gl.glRotatef(R2D*state[2], 0, 0, 1) gl.glColor3f(0,0,0); draw_mass_center(.1, (0,0)) gl.glPopMatrix() if len(state) >= 8: gl.glPushMatrix() gl.glTranslatef(0, self.h_body, 0) gl.glRotatef(R2D*state[3], 0, 0, 1) gl.glTranslatef(0, -self.h_body+self.r_roller+.05, 0) gl.glColor3f(0,0,0); draw_mass_center(.03, (0,0)) gl.glPopMatrix() gl.glPopMatrix();
def draw(self, win=None): """Draw the current frame to a particular visual.Window (or to the default win for this object if not specified). The current position in the movie will be determined automatically. This method should be called on every frame that the movie is meant to appear. """ if (self.status == NOT_STARTED or (self.status == FINISHED and self.loop)): self.play() elif self.status == FINISHED and not self.loop: return if win is None: win = self.win self._selectWindow(win) self._updateFrameTexture() # will check if it's needed # scale the drawing frame and get to centre of field GL.glPushMatrix() # push before drawing, pop after # push the data for client attributes GL.glPushClientAttrib(GL.GL_CLIENT_ALL_ATTRIB_BITS) self.win.setScale('pix') # move to centre of stimulus and rotate vertsPix = self.verticesPix # bind textures GL.glActiveTexture(GL.GL_TEXTURE1) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glEnable(GL.GL_TEXTURE_2D) GL.glActiveTexture(GL.GL_TEXTURE0) GL.glBindTexture(GL.GL_TEXTURE_2D, self._texID) GL.glEnable(GL.GL_TEXTURE_2D) # sets opacity (1,1,1 = RGB placeholder) GL.glColor4f(1, 1, 1, self.opacity) array = (GL.GLfloat * 32)( 1, 1, # texture coords vertsPix[0, 0], vertsPix[0, 1], 0., # vertex 0, 1, vertsPix[1, 0], vertsPix[1, 1], 0., 0, 0, vertsPix[2, 0], vertsPix[2, 1], 0., 1, 0, vertsPix[3, 0], vertsPix[3, 1], 0., ) # 2D texture array, 3D vertex array GL.glInterleavedArrays(GL.GL_T2F_V3F, 0, array) GL.glDrawArrays(GL.GL_QUADS, 0, 4) GL.glPopClientAttrib() GL.glPopAttrib() GL.glPopMatrix() # unbind the textures GL.glActiveTexture(GL.GL_TEXTURE0) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glEnable(GL.GL_TEXTURE_2D) # implicitly disables 1D
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 _draw_wireframe_display_list(self, dl): pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT) pgl.glPolygonMode(pgl.GL_FRONT_AND_BACK, pgl.GL_LINE) pgl.glEnable(pgl.GL_POLYGON_OFFSET_LINE) pgl.glPolygonOffset(-0.005, -50.0) pgl.glCallList(dl) pgl.glPopAttrib()
def unset_state(self): """ Disables the scissor test """ if not self.was_scissor_enabled: gl.glDisable(gl.GL_SCISSOR_TEST) gl.glPopAttrib()
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 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 buffer_texture(width, height): id_ = gl.GLuint() gl.glGenTextures(1, byref(id_)) gl.glPushAttrib(gl.GL_ENABLE_BIT | gl.GL_TEXTURE_BIT) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBindTexture(gl.GL_TEXTURE_2D, id_) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, (gl.GLubyte * (width*height * 4))(), ) gl.glFlush() gl.glBindTexture(gl.GL_TEXTURE_2D, 0) gl.glPopAttrib() return id_
def _draw(self): corner = c = self.octree.corner w = self.octree.width gl.glPushAttrib( gl.GL_ENABLE_BIT ) gl.glEnable( gl.GL_COLOR_MATERIAL ) if self.octree._child_nodes is None: if self.list_id: gl.glCallList(self.list_id) else: self.list_id = gl.glGenLists(1) gl.glNewList(self.list_id, gl.GL_COMPILE) gl.glColor3f(*self.color) gl.glBegin(gl.GL_LINE_LOOP) gl.glVertex3f(*c) gl.glVertex3f(*(c + (0,w,0))) gl.glVertex3f(*(c + (0,w,w))) gl.glVertex3f(*(c + (0,0,w))) gl.glEnd() c = corner + (w,0,0) gl.glBegin(gl.GL_LINE_LOOP) gl.glVertex3f(*c) gl.glVertex3f(*(c + (0,w,0))) gl.glVertex3f(*(c + (0,w,w))) gl.glVertex3f(*(c + (0,0,w))) gl.glEnd() gl.glBegin(gl.GL_LINES) gl.glVertex3f(*c) gl.glVertex3f(*(c - (w,0,0))) gl.glVertex3f(*(c + (0,w,0))) gl.glVertex3f(*(corner + (0,w,0))) gl.glVertex3f(*(c + (0,w,w))) gl.glVertex3f(*(corner + (0,w,w))) gl.glVertex3f(*(c + (0,0,w))) gl.glVertex3f(*(corner + (0,0,w))) gl.glEnd() gl.glEndList() # This could be optimized of course if self.octree._child_nodes is not None: r = self.color[0] + 0.14 if r < 1.0: r = r % 1.0 else: r = 1.0 b = max((self.color[2] - 0.14), 0) for node in self.octree._child_nodes.values(): if not self._cache.has_key(id(node)): self._cache[id(node)] = OctreeDebug(node, color=(r,0,b)) debugNode = self._cache[id(node)] debugNode._draw() gl.glColor3f(1,1,1) gl.glPopAttrib()
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 draw(self): super(ColorLayer, self).draw() gl.glPushMatrix() self.transform() gl.glPushAttrib(gl.GL_CURRENT_BIT) self._batch.draw() gl.glPopAttrib() gl.glPopMatrix()
def on_draw(self): with reset_matrix(self.w, self.h): gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) super().on_draw() gl.glPopAttrib()
def unbind(self): from pyglet import gl gl.glMatrixMode(gl.GL_MODELVIEW) gl.glPopMatrix() gl.glMatrixMode(gl.GL_PROJECTION) gl.glPopMatrix() gl.glPopAttrib() gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, 0) Framebuffer.current_fbo = None
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 draw_mass_center(r, pt): x,y = pt gl.glPushAttrib(gl.GL_CURRENT_BIT) gl.glColor3f(1,1,1) draw_circle(r, pt, filled=True) gl.glColor3f(0,0,0) draw_circle(r, pt, filled=False) draw_arc((r, r), pt, (0,pi/2)) draw_arc((r, r), pt, (pi,3*pi/2)) gl.glPopAttrib()
def render(self): from pyglet import gl gl.glPushAttrib(gl.GL_CURRENT_BIT) gl.glColor3f(1.0, 0.0, 0.0) for p in self._polys_top: gl.glBegin(gl.GL_LINE_STRIP) for i, q in enumerate(p): gl.glVertex2f(q[0], q[1]) gl.glVertex2f(p[0][0], p[0][1]) gl.glEnd() gl.glPopAttrib(gl.GL_CURRENT_BIT)
def draw(self): self.update_global_coords() self.update_elements() gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.batch.draw() gl.glPopAttrib()
def bind_draw(self): """Context for drawing into the FBO""" with self._bound_context(gl.GL_FRAMEBUFFER_EXT) as parent_fb: # Set viewport to the size of the texture gl.glPushAttrib(gl.GL_VIEWPORT_BIT) try: gl.glViewport(0, 0, self.width, self.height) yield parent_fb finally: # Restore old viewport! gl.glPopAttrib()
def _unset_view(self): gl.glMatrixMode(gl.GL_PROJECTION) gl.glPopMatrix() gl.glMatrixMode(self._mode.value) gl.glViewport( self._viewport[0], self._viewport[1], self._viewport[2], self._viewport[3], ) gl.glPopAttrib()
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 draw_special(self, style): """Draws the batch with special OpenGL attributes. Args: style (int): The style with which to draw the batch. """ glPushAttrib(GL_ENABLE_BIT) if style == self.DASHED_LINES: self._set_dashed_lines() self.draw() glPopAttrib()
def render(self): gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_BLEND) gl.glDisable(gl.GL_DEPTH_TEST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_TEXTURE_2D) gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT) for o in self.objects: o.draw() gl.glPopClientAttrib() gl.glPopAttrib()
def illuminate(self): if not self.is_fbo_valid(): self.fbo = FrameBuffer(self.viewport.w, self.viewport.h) #self.vl.vertices = self.viewport_coords() with self.fbo: gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glPushAttrib(gl.GL_ALL_ATTRIB_BITS) yield gl.glPopAttrib() if self.sh is None: self.sh = self._build_spatial_hash() self.render()
def draw(self, x, y, width, height): """Draw the nine-patch at the given image dimensions.""" width = max(width, self.width + 2) height = max(height, self.height + 2) vertices = self.get_vertices(int(x), int(y), int(width), int(height)) glPushAttrib(GL_ENABLE_BIT) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glEnable(self.texture.target) glBindTexture(self.texture.target, self.texture.id) pyglet.graphics.draw_indexed(16, GL_QUADS, self.indices, ('v2i', vertices), ('t2f', self.tex_coords)) glPopAttrib()
def draw(self): glPushMatrix() glPushAttrib(GL_STENCIL_BUFFER_BIT) glClear(GL_STENCIL_BUFFER_BIT) glTranslatef(self.parent.x, self.parent.y, 0) glDisable(GL_TEXTURE_2D) loader = self.loader if loader.shape == LINE_SHAPE: glEnable(GL_LINE_SMOOTH) glEnable(GL_POINT_SMOOTH) glLineWidth(loader.borderSize) glPointSize(loader.borderSize) self.vertex.draw(GL_LINES) self.vertex.draw(GL_POINTS) elif loader.shape == RECTANGLE_SHAPE: width = self.parent.width height = self.parent.height if loader.fillType != NONE_FILL: # for counters if self.counter_stencil: glEnable(GL_STENCIL_TEST) glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE) glStencilFunc(GL_ALWAYS, 1, 1) glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE) self.counter_stencil.draw(GL_QUADS) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glStencilFunc(GL_EQUAL, 1, 1) self.draw_rectangle() glDisable(GL_STENCIL_TEST) else: self.draw_rectangle() if self.border is not None: self.border.draw(GL_QUADS) elif loader.shape == ELLIPSE_SHAPE: if loader.fillType != NONE_FILL: glEnable(GL_STENCIL_TEST) glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE) glStencilFunc(GL_ALWAYS, 1, 1) glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE) self.stencil.draw(GL_TRIANGLES) glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE) glStencilFunc(GL_EQUAL, 1, 1) self.draw_rectangle(True) glDisable(GL_STENCIL_TEST) if self.border: self.border.draw(GL_QUADS) glPopAttrib() glPopMatrix()
def draw_image(self, img, rect=None, force_copy=False): """ Renders a GraphicsContextArray into this GC """ xform = self.get_ctm() x0 = xform[4] y0 = xform[5] image = image_as_array(img) shape = image.shape if shape[2] == 4: fmt = "RGBA" else: fmt = "RGB" aii = ArrayImage(image, format=fmt) texture = aii.texture # The texture coords consists of (u,v,r) for each corner of the # texture rectangle. The coordinates are stored in the order # bottom left, bottom right, top right, top left. x, y, w, h = rect texture.width = w texture.height = h t = texture.tex_coords points = array([ [x, y+h], [x+w, y+h], [x+w, y], [x, y], ]) p = transform_points(affine_from_values(*xform), points) a = (gl.GLfloat*32)( t[0], t[1], t[2], 1., p[0,0], p[0,1], 0, 1., t[3], t[4], t[5], 1., p[1,0], p[1,1], 0, 1., t[6], t[7], t[8], 1., p[2,0], p[2,1], 0, 1., t[9], t[10], t[11], 1., p[3,0], p[3,1], 0, 1., ) gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(texture.target) gl.glBindTexture(texture.target, texture.id) gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT) gl.glInterleavedArrays(gl.GL_T4F_V4F, 0, a) gl.glDrawArrays(gl.GL_QUADS, 0, 4) gl.glPopClientAttrib() gl.glPopAttrib()
def render(self): from pyglet import gl gl.glPushAttrib(gl.GL_CURRENT_BIT) gl.glColor3f(1.0, 0.0, 0.0) # Here we'll render each waypoint as a red square. for (_, _, x, y) in self._waypoints: gl.glBegin(gl.GL_QUADS) gl.glVertex2f(x-2, y-4) gl.glVertex2f(x+2, y-4) gl.glVertex2f(x+2, y+4) gl.glVertex2f(x-2, y+4) gl.glEnd() gl.glLineWidth(3) # And let's draw a line between each waypoint, so we know where we're going next. gl.glBegin(gl.GL_LINE_STRIP) for (_, _, x, y) in self._waypoints: gl.glVertex2f(x, y) gl.glEnd() gl.glPopAttrib(gl.GL_CURRENT_BIT)
def blit_image(self, matrix, position, scale, image): x, y = image.width * scale, image.height * scale # dx = self.x + position[0] # dy = self.y + position[1] dx, dy = position gl.glEnable(image.target) gl.glBindTexture(image.target, image.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) # blit img points = [ (-dx, -dy), (x - dx, -dy), (x - dx, y - dy), (-dx, y - dy) ] a, b, _, c, d, _, e, f, _, g, h, _ = image.texture.tex_coords textures = [a, b, c, d, e, f, g, h] np = [matrix * euclid.Point2(*p) for p in points] gl.glColor4ub(255, 255, 255, self.alpha) gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(a, b) gl.glVertex2f(*np[0]) gl.glTexCoord2f(c, d) gl.glVertex2f(*np[1]) gl.glTexCoord2f(e, f) gl.glVertex2f(*np[2]) gl.glTexCoord2f(g, h) gl.glVertex2f(*np[3]) gl.glEnd() gl.glColor4ub(255, 255, 255, 255) # pyglet.graphics.draw(4, GL_QUADS, # ("v2f", new_points), # ("t2f", textures), # ("c4B", [255, 255, 255, self.alpha] * 4), # ) gl.glPopAttrib() gl.glDisable(image.target)
def render(self): """Draw contained objects. """ if not self.objects: return r = 32 self._set_2d(0, r*4) gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(gl.GL_BLEND) gl.glDisable(gl.GL_DEPTH_TEST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) import miru.graphics for v in self.objects: v.draw() #print '-- %r' % v #print '\n'.join([ str(t) for t in miru.graphics.TextureTool.current_parameters()]) gl.glColor4f(1,1,1,1) gl.glPopAttrib() self._unset_2d()
def _draw_solid_display_list(self, dl): pgl.glPushAttrib(pgl.GL_ENABLE_BIT | pgl.GL_POLYGON_BIT) pgl.glPolygonMode(pgl.GL_FRONT_AND_BACK, pgl.GL_FILL) pgl.glCallList(dl) pgl.glPopAttrib()
def unset_state(self): """ Restore previous blending state. """ gl.glPopAttrib()
def gl_state(bits=gl.GL_ALL_ATTRIB_BITS): gl.glPushAttrib(bits) try: yield finally: gl.glPopAttrib()
def unset_state(self): glDisable(GL_BLEND) glPopAttrib()
def draw_image(self, img, rect=None, force_copy=False): """ Renders a GraphicsContextArray into this GC """ xform = self.get_ctm() image = image_as_array(img) shape = image.shape if shape[2] == 4: fmt = "RGBA" else: fmt = "RGB" aii = ArrayImage(image, format=fmt) texture = aii.texture # The texture coords consists of (u,v,r) for each corner of the # texture rectangle. The coordinates are stored in the order # bottom left, bottom right, top right, top left. x, y, w, h = rect texture.width = w texture.height = h t = texture.tex_coords points = array([ [x, y + h], [x + w, y + h], [x + w, y], [x, y], ]) p = transform_points(affine_from_values(*xform), points) a = (gl.GLfloat * 32)( t[0], t[1], t[2], 1., p[0, 0], p[0, 1], 0, 1., t[3], t[4], t[5], 1., p[1, 0], p[1, 1], 0, 1., t[6], t[7], t[8], 1., p[2, 0], p[2, 1], 0, 1., t[9], t[10], t[11], 1., p[3, 0], p[3, 1], 0, 1., ) gl.glPushAttrib(gl.GL_ENABLE_BIT) gl.glEnable(texture.target) gl.glBindTexture(texture.target, texture.id) gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT) gl.glInterleavedArrays(gl.GL_T4F_V4F, 0, a) gl.glDrawArrays(gl.GL_QUADS, 0, 4) gl.glPopClientAttrib() gl.glPopAttrib()
def deactivate(self, *args): gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, 0) gl.glPopAttrib()
def renderToTexture(w, h, function): import ctypes from pyglet import gl from pyglet import image from pyglet.gl import gl_info global has_fbo if has_fbo is None: has_fbo = gl_info.have_extension('GL_EXT_framebuffer_object') # enforce dimensions are ints w, h = int(w), int(h) # set up viewport gl.glPushAttrib(gl.GL_VIEWPORT_BIT | gl.GL_TRANSFORM_BIT) gl.glViewport(0, 0, w, h) gl.glMatrixMode(gl.GL_PROJECTION) gl.glPushMatrix() gl.glLoadIdentity() gl.glOrtho(0, w, 0, h, -1, 1) gl.glMatrixMode(gl.GL_MODELVIEW) if has_fbo: # render directly to texture # create our frame buffer fbo = gl.GLuint() gl.glGenFramebuffersEXT(1, ctypes.byref(fbo)) gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, fbo) # allocate a texture and add to the frame buffer tex = image.Texture.create_for_size(gl.GL_TEXTURE_2D, w, h, gl.GL_RGBA) gl.glBindTexture(gl.GL_TEXTURE_2D, tex.id) gl.glFramebufferTexture2DEXT(gl.GL_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT, gl.GL_TEXTURE_2D, tex.id, 0) status = gl.glCheckFramebufferStatusEXT(gl.GL_FRAMEBUFFER_EXT) assert status == gl.GL_FRAMEBUFFER_COMPLETE_EXT # now render gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, fbo) function() gl.glBindFramebufferEXT(gl.GL_FRAMEBUFFER_EXT, 0) # clean up gl.glDeleteFramebuffersEXT(1, ctypes.byref(fbo)) else: # render and copy to texture # render function() # grab the buffer and copy contents to the texture buffer = image.get_buffer_manager().get_color_buffer() tex = image.Texture.create_for_size(gl.GL_TEXTURE_2D, w, h, gl.GL_RGBA) tex.blit_into(buffer.get_region(0, 0, w, h), 0, 0, 0) gl.glMatrixMode(gl.GL_PROJECTION) gl.glPopMatrix() gl.glPopAttrib() # return the region (the whole texture will most likely be larger) return tex.get_region(0, 0, w, h)
def draw(self): """Draw the particles system""" gl.glPushMatrix() self.transform() # color preserve - at least nvidia 6150SE needs that gl.glPushAttrib(gl.GL_CURRENT_BIT) # glPointSize(self.get_scaled_particle_size()) gl.glEnable(gl.GL_TEXTURE_2D) gl.glEnable(gl.GL_PROGRAM_POINT_SIZE) # glBindTexture(GL_TEXTURE_2D, self.texture.id) gl.glEnable(gl.GL_POINT_SPRITE) gl.glTexEnvi(gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) vertex_ptr = PointerToNumpy(self.particle_pos) gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertex_ptr) gl.glEnableClientState(gl.GL_COLOR_ARRAY) color_ptr = PointerToNumpy(self.particle_color) gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr) gl.glEnableVertexAttribArray(self.particle_size_idx) size_ptr = PointerToNumpy(self.particle_size_scaled) gl.glVertexAttribPointer(self.particle_size_idx, 1, gl.GL_FLOAT, False, 0, size_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) # mode = GLint() # glTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode ) # # if self.color_modulate: # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) # else: # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ) self.sprite_shader.install() self.sprite_shader.usetTex('sprite_texture', 0, gl.GL_TEXTURE_2D, self.texture.id) gl.glDrawArrays(gl.GL_POINTS, 0, self.total_particles) self.sprite_shader.uninstall() # un -blend gl.glPopAttrib() # color restore gl.glPopAttrib() # restore env mode # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode) # disable states gl.glDisableVertexAttribArray(self.particle_size_idx) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisable(gl.GL_POINT_SPRITE) gl.glDisable(gl.GL_PROGRAM_POINT_SIZE) gl.glDisable(gl.GL_TEXTURE_2D) gl.glPopMatrix()
def draw(self): gl.glPushMatrix() self.transform() # color preserve - at least nvidia 6150SE needs that gl.glPushAttrib(gl.GL_CURRENT_BIT) # glPointSize(self.get_scaled_particle_size()) gl.glEnable(gl.GL_TEXTURE_2D) gl.glEnable(gl.GL_PROGRAM_POINT_SIZE) # glBindTexture(GL_TEXTURE_2D, self.texture.id) gl.glEnable(gl.GL_POINT_SPRITE) gl.glTexEnvi(gl.GL_POINT_SPRITE, gl.GL_COORD_REPLACE, gl.GL_TRUE) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) vertex_ptr = PointerToNumpy(self.particle_pos) gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertex_ptr) gl.glEnableClientState(gl.GL_COLOR_ARRAY) color_ptr = PointerToNumpy(self.particle_color) gl.glColorPointer(4, gl.GL_FLOAT, 0, color_ptr) gl.glEnableVertexAttribArray(self.particle_size_idx) size_ptr = PointerToNumpy(self.particle_size_scaled) gl.glVertexAttribPointer(self.particle_size_idx, 1, gl.GL_FLOAT, False, 0, size_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) # mode = GLint() # glTexEnviv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode ) # # if self.color_modulate: # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ) # else: # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ) self.sprite_shader.install() self.sprite_shader.usetTex('sprite_texture', 0, gl.GL_TEXTURE_2D, self.texture.id) gl.glDrawArrays(gl.GL_POINTS, 0, self.total_particles) self.sprite_shader.uninstall() # un -blend gl.glPopAttrib() # color restore gl.glPopAttrib() # restore env mode # glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode) # disable states gl.glDisableVertexAttribArray(self.particle_size_idx) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisable(gl.GL_POINT_SPRITE) gl.glDisable(gl.GL_PROGRAM_POINT_SIZE) gl.glDisable(gl.GL_TEXTURE_2D) gl.glPopMatrix()
def __exit__ (self, type, value, traceback): gl.glPopAttrib()
def unset_state(self): gl.glPopAttrib()
def __exit__ (self, type, value, traceback): gl.glMatrixMode(self.matrix_mode) gl.glPopMatrix() gl.glPopAttrib()
def unset_state(self): super(TileLayerGroup, self).unset_state() gl.glPopMatrix() gl.glPopAttrib()
def unset_state(self): glPopAttrib()
def unbind(self): from pyglet.gl import glPopAttrib glPopAttrib()