def display(self, mode_2d=False): glPushMatrix() glTranslatef(self.offset_x, self.offset_y, 0) glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_COLOR_ARRAY) self._display_movements(mode_2d) glDisableClientState(GL_COLOR_ARRAY) glDisableClientState(GL_VERTEX_ARRAY) glPopMatrix()
def __exit__(self, *args): for idx in self.state: texuint = 0 if hasattr(idx, "__len__"): texunit = idx[1] idx = idx[0] if idx in self.ClientState: if idx == gl.GL_TEXTURE_COORD_ARRAY: gl.glClientActiveTexture(GL_TEXTURE0 + texunit) gl.glDisableClientState(idx) else: gl.glDisable(idx)
def draw_hud(self): ''' Draw any display items overlaid on the world, such as FPS counter ''' self.projection.set_screen() self.modelview.set_identity() gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) self.clock_display.draw() gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY)
def render_points(self): renderPoints = [] for point in self.points: renderPoints.extend(point.position.vector) self.ctPoints = (gl.GLfloat * len(renderPoints))(*renderPoints) point_ptr = ct.cast(self.ctPoints, ct.c_void_p) gl.glColor3f(1.0, 1.0, 1.0) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_ptr) gl.glDrawArrays(gl.GL_POINTS, 0, len(renderPoints)//2) gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def drawlines( self, verts, colors, idxs ): 'helper to draw lines from numpy arrays of verts/colors/indexes' vptr = vecutil.numpy2pointer(verts) iptr = vecutil.numpy2pointer(idxs) if colors is not None: cptr = vecutil.numpy2pointer(colors) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glColorPointer(3, gl.GL_FLOAT, 0, cptr) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(3, gl.GL_FLOAT, 0, vptr) gl.glDrawElements(gl.GL_LINES, len(idxs), gl.GL_UNSIGNED_INT, iptr) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY)
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 display(self, mode_2d=False): glPushMatrix() glTranslatef(self.offset_x, self.offset_y, 0) glEnableClientState(GL_VERTEX_ARRAY) has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) self._display_travels(has_vbo) glEnableClientState(GL_COLOR_ARRAY) self._display_movements(has_vbo) glDisableClientState(GL_COLOR_ARRAY) glDisableClientState(GL_VERTEX_ARRAY) glPopMatrix()
def draw_hud(self, items): ''' Draw any display items overlaid on the world, such as FPS counter ''' self.camera.hud_projection() rabbyt.render_unsorted( items ) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) if self.options.fps: if self.clock_display is None: self.clock_display = clock.ClockDisplay() self.clock_display.draw() gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY)
def paintGL(self): gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glLoadIdentity() #draw lines gl.glEnableClientState(gl.GL_COLOR_ARRAY) self.lineVerts = (self.spl.segments + self.centre).flatten() self.lineVerts_gl = (gl.GLfloat * len(self.lineVerts))(*self.lineVerts) self.lineColors = (self.spl.segColor).flatten() self.lineColors_gl = (gl.GLfloat * len(self.lineColors))(*self.lineColors) gl.glVertexPointer(2, gl.GL_FLOAT, 0, self.lineVerts_gl) gl.glColorPointer(4, gl.GL_FLOAT, 0, self.lineColors_gl) gl.glDrawArrays(gl.GL_LINES, 0, len(self.lineVerts) // 2) gl.glDisableClientState(gl.GL_COLOR_ARRAY) #draw points gl.glColor3f(1.0, 1.0, 1.0) vertPoints = (self.spl.state[:, :2] + self.centre).flatten().astype( ctypes.c_float) vertices_gl = vertPoints.ctypes.data_as(ctypes.POINTER(ctypes.c_float)) gl.glVertexPointer(2, gl.GL_FLOAT, 0, vertices_gl) gl.glDrawArrays(gl.GL_POINTS, 0, len(vertPoints) // 2) #overdraw selected point if self.spl.clicked != -1: gl.glColor3f(1.0, 0.0, 0.0) point = (self.spl.clickedState[:2] + self.centre).astype( ctypes.c_float) point_gl = point.ctypes.data_as(ctypes.POINTER(ctypes.c_float)) gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_gl) gl.glDrawArrays(gl.GL_POINTS, 0, 1) pyglet.text.Label("Epoch: %s" % self.secStruct.epochCount, x=5, y=10, font_name='Times New Roman', font_size=20).draw()
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 drawnvc( self, normals, points, colors, idxs ): '''draw tri mesh using glDrawElements using input normals points colors and indexes''' n = 1 for dim in idxs.shape: n *= dim iptr = vecutil.numpy2pointer(idxs) nptr = vecutil.numpy2pointer(normals) vptr = vecutil.numpy2pointer(points) cptr = vecutil.numpy2pointer(colors) mode = self.ui.fillmodes[self.ui.fillmode] gl.glPolygonMode( gl.GL_FRONT, mode ) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_NORMAL_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glVertexPointer(3, gl.GL_FLOAT, 0, vptr) gl.glNormalPointer( gl.GL_FLOAT, 0, nptr) gl.glColorPointer(3, gl.GL_FLOAT, 0, cptr) gl.glDrawElements(gl.gl.GL_TRIANGLES, n, gl.GL_UNSIGNED_INT, iptr) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_NORMAL_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glPolygonMode( gl.GL_FRONT, gl.GL_FILL )
def draw(self): """Draw the text to the back buffer""" # Border width self.box.setLineWidth( self.palette['lineWidth']) # Use 1 as base if border width is none #self.borderWidth = self.box.lineWidth # Border colour self.box.setLineColor(self.palette['lineColor'], colorSpace='rgb') #self.borderColor = self.box.lineColor # Background self.box.setFillColor(self.palette['fillColor'], colorSpace='rgb') #self.fillColor = self.box.fillColor if self._needVertexUpdate: #print("Updating vertices...") self._updateVertices() if self.fillColor is not None or self.borderColor is not None: self.box.draw() # self.boundingBox.draw() # could draw for debug purposes gl.glPushMatrix() self.win.setScale('pix') gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, self.glFont.textureID) gl.glEnable(gl.GL_TEXTURE_2D) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_DOUBLE, 0, self.verticesPix.ctypes) gl.glColorPointer(4, gl.GL_DOUBLE, 0, self._colors.ctypes) gl.glTexCoordPointer(2, gl.GL_DOUBLE, 0, self._texcoords.ctypes) self.shader.bind() self.shader.setInt('texture', 0) self.shader.setFloat('pixel', [1.0 / 512, 1.0 / 512]) nVerts = len(self._text) * 4 gl.glDrawArrays(gl.GL_QUADS, 0, nVerts) self.shader.unbind() # removed the colors and font texture gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glDisableVertexAttribArray(1) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) gl.glDisable(gl.GL_TEXTURE_2D) if self.hasFocus: # draw caret line self.caret.draw() gl.glPopMatrix()
def draw_background(self): varray = [] carray = [] x = self.top_left['x'] y = self.top_left['y'] for _ in self.background: basePosition = _[0] depth = _[1] color = _[2] #parallax scrolling and wrapping realPosition = (basePosition[0] + x * depth, basePosition[1] + y * depth) wrappedPosition = ( realPosition[0] % self.background_width, realPosition[1] % self.background_height) varray += [wrappedPosition[0], wrappedPosition[1], 0] carray += color # # # needs to be commented and understood.. # glEnable(GL_BLEND) # glEnable(GL_VERTEX_PROGRAM_POINT_SIZE) # point_size = GLfloat(10.0) # glGetFloatv(GL_POINT_SIZE_MAX_ARB, point_size) # glPointSize(point_size) # glPointParameterfvARB(GL_POINT_DISTANCE_ATTENUATION_ARB, (GLfloat * 3)(0, 0, 5)) # glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 5) varray = (GLfloat * len(varray))(*varray) carray = (GLfloat * len(carray))(*carray) glVertexPointer(3, GL_FLOAT, 0, varray) glColorPointer(4, GL_FLOAT, 0, carray) glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_COLOR_ARRAY) glDrawArrays(GL_POINTS, 0, len(varray)//3) glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY);
def render_bounding_box(self): gl.glLineWidth(1.0) self.ctPoints = self.ctPointT( self.rect.min.x, self.rect.min.y, self.rect.max.x, self.rect.min.y, self.rect.max.x, self.rect.min.y, self.rect.max.x, self.rect.max.y, self.rect.max.x, self.rect.max.y, self.rect.min.x, self.rect.max.y, self.rect.min.x, self.rect.max.y, self.rect.min.x, self.rect.min.y, ) point_ptr = ct.cast(self.ctPoints, ct.c_void_p) gl.glColor3f(*self.bbColor) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glVertexPointer(2, gl.GL_FLOAT, 0, point_ptr) gl.glDrawArrays(gl.GL_LINES, 0, 8) gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
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(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 _display_movements(self, mode_2d=False): self.vertex_buffer.bind() has_vbo = isinstance(self.vertex_buffer, VertexBufferObject) if has_vbo: glVertexPointer(3, GL_FLOAT, 0, None) else: glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) self.vertex_color_buffer.bind() if has_vbo: glColorPointer(4, GL_FLOAT, 0, None) else: glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr) start = 0 if self.num_layers_to_draw <= self.max_layers: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] else: end_prev_layer = -1 end = self.layer_stops[min(self.num_layers_to_draw, self.max_layers)] glDisableClientState(GL_COLOR_ARRAY) glColor4f(*self.color_printed) # Draw printed stuff until end or end_prev_layer cur_end = min(self.printed_until, end) if not self.only_current: if 0 <= end_prev_layer <= cur_end: glDrawArrays(GL_LINES, start, end_prev_layer) elif cur_end >= 0: glDrawArrays(GL_LINES, start, cur_end) glEnableClientState(GL_COLOR_ARRAY) # Draw nonprinted stuff until end_prev_layer start = max(cur_end, 0) if end_prev_layer >= start: if not self.only_current: glDrawArrays(GL_LINES, start, end_prev_layer - start) cur_end = end_prev_layer # Draw current layer if end_prev_layer >= 0: glDisableClientState(GL_COLOR_ARRAY) # Backup & increase line width orig_linewidth = (GLfloat)() glGetFloatv(GL_LINE_WIDTH, orig_linewidth) glLineWidth(2.0) glColor4f(*self.color_current_printed) if cur_end > end_prev_layer: glDrawArrays(GL_LINES, end_prev_layer, cur_end - end_prev_layer) glColor4f(*self.color_current) if end > cur_end: glDrawArrays(GL_LINES, cur_end, end - cur_end) # Restore line width glLineWidth(orig_linewidth) glEnableClientState(GL_COLOR_ARRAY) # Draw non printed stuff until end (if not ending at a given layer) start = max(self.printed_until, 0) end = end - start if end_prev_layer < 0 and end > 0 and not self.only_current: glDrawArrays(GL_LINES, start, end) self.vertex_buffer.unbind() self.vertex_color_buffer.unbind()
def _display_movements(self, has_vbo): self.vertex_buffer.bind() if has_vbo: glVertexPointer(3, GL_FLOAT, 0, None) else: glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) self.vertex_color_buffer.bind() if has_vbo: glColorPointer(4, GL_FLOAT, 0, None) else: glColorPointer(4, GL_FLOAT, 0, self.vertex_color_buffer.ptr) self.index_buffer.bind() start = 1 layer_selected = self.num_layers_to_draw <= self.max_layers if layer_selected: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] else: end_prev_layer = 0 end = self.layer_stops[min(self.num_layers_to_draw, self.max_layers)] glDisableClientState(GL_COLOR_ARRAY) glColor4f(*self.color_printed) # Draw printed stuff until end or end_prev_layer cur_end = min(self.printed_until, end) if not self.only_current: if 1 <= end_prev_layer <= cur_end: self._draw_elements(1, end_prev_layer) elif cur_end >= 1: self._draw_elements(1, cur_end) glEnableClientState(GL_COLOR_ARRAY) # Draw nonprinted stuff until end_prev_layer start = max(cur_end, 1) if end_prev_layer >= start: if not self.only_current: self._draw_elements(start, end_prev_layer) cur_end = end_prev_layer # Draw current layer if layer_selected: glDisableClientState(GL_COLOR_ARRAY) # Backup & increase line width orig_linewidth = (GLfloat)() glGetFloatv(GL_LINE_WIDTH, orig_linewidth) glLineWidth(2.0) glColor4f(*self.color_current_printed) if cur_end > end_prev_layer: self._draw_elements(end_prev_layer + 1, cur_end) glColor4f(*self.color_current) if end > cur_end: self._draw_elements(cur_end + 1, end) # Restore line width glLineWidth(orig_linewidth) glEnableClientState(GL_COLOR_ARRAY) # Draw non printed stuff until end (if not ending at a given layer) start = max(self.printed_until, 1) if not layer_selected and end >= start: self._draw_elements(start, end) self.vertex_buffer.unbind() self.vertex_color_buffer.unbind()
def _display_movements(self, has_vbo): self.vertex_buffer.bind() glVertexPointer(3, GL_FLOAT, 0, self.vertex_buffer.ptr) self.vertex_color_buffer.bind() glColorPointer(3, GL_FLOAT, 0, self.vertex_color_buffer.ptr) self.vertex_normal_buffer.bind() glNormalPointer(GL_FLOAT, 0, self.vertex_normal_buffer.ptr) self.index_buffer.bind() # Prevent race condition by using the number of currently loaded layers max_layers = self.layers_loaded start = 1 layer_selected = self.num_layers_to_draw <= max_layers if layer_selected: end_prev_layer = self.layer_stops[self.num_layers_to_draw - 1] else: end_prev_layer = 0 end = self.layer_stops[min(self.num_layers_to_draw, max_layers)] glDisableClientState(GL_COLOR_ARRAY) glColor3f(*self.color_printed[:-1]) # Draw printed stuff until end or end_prev_layer cur_end = min(self.printed_until, end) if not self.only_current: if 1 <= end_prev_layer <= cur_end: self._draw_elements(1, end_prev_layer) elif cur_end >= 1: self._draw_elements(1, cur_end) glEnableClientState(GL_COLOR_ARRAY) # Draw nonprinted stuff until end_prev_layer start = max(cur_end, 1) if end_prev_layer >= start: if not self.only_current: self._draw_elements(start, end_prev_layer) cur_end = end_prev_layer # Draw current layer if layer_selected: glDisableClientState(GL_COLOR_ARRAY) glColor3f(*self.color_current_printed[:-1]) if cur_end > end_prev_layer: self._draw_elements(end_prev_layer + 1, cur_end) glColor3f(*self.color_current[:-1]) if end > cur_end: self._draw_elements(cur_end + 1, end) glEnableClientState(GL_COLOR_ARRAY) # Draw non printed stuff until end (if not ending at a given layer) start = max(self.printed_until, 1) if not layer_selected and end >= start: self._draw_elements(start, end) self.index_buffer.unbind() self.vertex_buffer.unbind() self.vertex_color_buffer.unbind() self.vertex_normal_buffer.unbind()
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 drawVertexbuffers(vertexBuffer, *args, mode=GL.GL_TRIANGLES, flush=True): """Draw a vertex buffer using glDrawArrays. This method does not require shaders. Parameters ---------- vertexBuffer : :obj:`Vertexbuffer` Vertex buffer descriptor, must have 'bufferType' as GL_VERTEX_ARRAY. Optional vertex buffer descriptors can be passed as seperate arguments, they must have 'bufferTypes' as GL_TEXTURE_COORD_ARRAY, GL_NORMAL_ARRAY or GL_COLOR_ARRAY. mode : :obj:`int` Drawing mode to use (e.g. GL_TRIANGLES, GL_QUADS, GL_POINTS, etc.) flush : :obj:`bool` Flush queued drawing commands before returning. Returns ------- None Examples -------- # vertices of a triangle verts = [ 1.0, 1.0, 0.0, # v0 0.0, -1.0, 0.0, # v1 -1.0, 1.0, 0.0] # v2 # triangle vertex colors colors = [1.0, 0.0, 0.0, # v0 0.0, 1.0, 0.0, # v1 0.0, 0.0, 1.0] # v2 # load vertices to graphics device, return a descriptor vertexBuffer = createVertexbuffer(verts, 3) colorBuffer = createVertexbuffer(c, 3, GL.GL_COLOR_ARRAY) # draw the VBO drawVertexbuffer(vertexBuffer, colorBuffer, GL.GL_TRIANGLES) """ # must have a vertex pointer assert vertexBuffer.bufferType == GL.GL_VERTEX_ARRAY # bind and set the vertex pointer GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBuffer.id) GL.glVertexPointer(vertexBuffer.vertexSize, vertexBuffer.dtype, 0, None) GL.glEnableClientState(vertexBuffer.bufferType) # handle additional buffers if args: for buffer in args: # check if the number of indicies are the same if vertexBuffer.indices != buffer.indices: raise RuntimeError("Vertex buffer indices do not match!") GL.glBindBuffer(GL.GL_ARRAY_BUFFER, buffer.id) if buffer.bufferType == GL.GL_TEXTURE_COORD_ARRAY: GL.glTexCoordPointer(buffer.dtype, 0, None) elif buffer.bufferType == GL.GL_NORMAL_ARRAY: GL.glNormalPointer(buffer.dtype, 0, None) elif buffer.bufferType == GL.GL_COLOR_ARRAY: GL.glColorPointer(buffer.vertexSize, buffer.dtype, 0, None) GL.glEnableClientState(buffer.bufferType) GL.glDrawArrays(mode, 0, vertexBuffer.indices) # draw arrays # reset GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0) GL.glDisableClientState(vertexBuffer.bufferType) if args: for vbo in args: GL.glDisableClientState(vbo.bufferType) if flush: GL.glFlush()