def display(self): now = time.time() timedelt = now-self.timestamp self.timestamp = now self.current_fps = 1.0/timedelt hid_js.read_js(self.camera) view = self.camera.matrix() # updating shared variables in shader data block. Also see # timer() self.shader_data_block.map() self.shader_data_block.set('u_view', view) self.shader_data_block.set("camera_position", np.array(self.camera.loc, dtype=np.float32)) self.light_count += 1 if self.light_count == 2: self.light_count = 0 self.lights = self.get_lights() self.shader_data_block.set("light_diffuse", np.array(self.lights, dtype=np.float32)) self.shader_data_block.unmap() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) for drawable in self.drawables: drawable.draw() glut.glutSwapBuffers()
def on_display( ): global shader gl.glClearColor(1,1,1,1) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) gl.glColor(0,0,0,1) shader.bind() radius = 255.0 theta, dtheta = 0, 5.5/180.0*math.pi support = 0.75 thickness = 1.0 for i in range(500): x = 256+radius*math.cos(theta); y = 32+256+radius*math.sin(theta); r = 10.1-i*0.02 circle( (x,y,r), thickness=thickness, support=support ) radius -= 0.45 theta += dtheta for i in range(0,39): r = 4 thickness = (i+1)/10.0 x = 20+i*12.5 - r y = 16 circle( (x,y,r), thickness=thickness, support=support ) glut.glutSwapBuffers( )
def draw(self): self.execute() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() #handle mouse transformations gl.glTranslatef(self.initrans[0], self.initrans[1], self.initrans[2]) gl.glRotatef(self.rotate[0], 1, 0, 0) gl.glRotatef(self.rotate[1], 0, 1, 0) #we switched around the axis so make this rotate_z gl.glTranslatef(self.translate[0], self.translate[1], self.translate[2]) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glPointSize(5) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.arrvbo.bind() gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glVertexPointer(4, gl.GL_FLOAT, 0, self.arrvbo) self.colvbo.bind() gl.glColorPointer(4, gl.GL_FLOAT, 0, self.colvbo) gl.glDrawArrays(gl.GL_POINTS, 0, self.size**3) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) self.arrvbo.unbind() self.colvbo.unbind() glut.glutSwapBuffers() if self.makeMovie: gl.glReadPixels(0,0,800,600,gl.GL_RGB, gl.GL_UNSIGNED_BYTE, array=self.curimage) fname = '_tmp%05d.png'%self.curindex scipy.misc.imsave(fname, self.curimage) self.curindex += 1
def drawGLScene(): gl.glLoadIdentity() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) cube.drawCube() glut.glutSwapBuffers()
def on_display(): global cube, theta, phi, frame, time, timebase frame += 1 time = glut.glutGet( glut.GLUT_ELAPSED_TIME ) if (time - timebase > 1000): print frame*1000.0/(time-timebase) timebase = time; frame = 0; gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glPushMatrix() gl.glRotatef(theta, 0,0,1) gl.glRotatef(phi, 0,1,0) gl.glDisable( gl.GL_BLEND ) gl.glEnable( gl.GL_LIGHTING ) gl.glEnable( gl.GL_DEPTH_TEST ) gl.glEnable( gl.GL_POLYGON_OFFSET_FILL ) gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_FILL ) cube.draw( gl.GL_QUADS, 'pnc' ) gl.glDisable( gl.GL_POLYGON_OFFSET_FILL ) gl.glEnable( gl.GL_BLEND ) gl.glDisable( gl.GL_LIGHTING ) gl.glPolygonMode( gl.GL_FRONT_AND_BACK, gl.GL_LINE ) gl.glDepthMask( gl.GL_FALSE ) gl.glColor( 0.0, 0.0, 0.0, 0.5 ) cube.draw( gl.GL_QUADS, 'p' ) gl.glDepthMask( gl.GL_TRUE ) gl.glPopMatrix() glut.glutSwapBuffers()
def display(self, camera_tr_vec, camera_rot_mat, camera_fov_y, tracked_cam_track_pos_float): """ Draw everything with specified render camera position, projection parameters and tracked camera position :param camera_tr_vec: vec3 position of render camera in global space :param camera_rot_mat: mat3 rotation matrix of render camera in global space :param camera_fov_y: render camera field of view. To be used for building a projection matrix. Use glutGet to calculate current aspect ratio :param tracked_cam_track_pos_float: a frame in which tracked camera model and frustrum should be drawn (see tracked_cam_track_pos for basic task) :return: returns nothing """ # a frame in which a tracked camera model and frustrum should be drawn # without interpolation tracked_cam_track_pos = int(tracked_cam_track_pos_float) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) model = np.diag([1, -1, -1, 1]).astype(np.float32) view = self._view_matrix(camera_tr_vec, camera_rot_mat) projection = self._projection_matrix_from_fovy(camera_fov_y) mvp = projection.dot(view.dot(model)) # Cloud of points self._render_object(mvp, self._cloud_points_buffer, self._cloud_colors_buffer, self._vertex_program, self._n_cloud_points) # Camera track # print(self._camera_track_positions[:tracked_cam_track_pos + 1]) self._render_object(mvp, self._bufferize(self._camera_track_positions[:tracked_cam_track_pos + 1]), self._white, self._fragment_program, tracked_cam_track_pos + 1, uniform_color=True, drawing_object=GL.GL_LINE_STRIP) # Frustum frustum_corners = self._frustum_corners(camera_fov_y, self._camera_track_positions[tracked_cam_track_pos], self._camera_track_rotations[tracked_cam_track_pos]) self._render_object(mvp, self._bufferize(frustum_corners), self._yellow, self._fragment_program, 4, uniform_color=True, drawing_object=GL.GL_LINE_LOOP) self._render_object(mvp, self._bufferize(np.array( [[self._camera_track_positions[tracked_cam_track_pos], p] for p in frustum_corners] )), self._yellow, self._fragment_program, 8, uniform_color=True, drawing_object=GL.GL_LINES) camera_pos = self._camera_track_positions[tracked_cam_track_pos] camera_rot = self._camera_track_rotations[tracked_cam_track_pos] rot_matrix = np.diag([-1., -1., -1.]) camera_vertices = np.array([rot_matrix.dot(camera_rot.dot(v)) + camera_pos for v in self._camera_vertices], dtype=np.float32) self._render_object(mvp, self._bufferize(camera_vertices), self._blue, self._fragment_program, self._n_camera_vertices, uniform_color=True, drawing_object=GL.GL_TRIANGLES) GLUT.glutSwapBuffers()
def render_routine(): global render_time_list global render_left global render_right gl.glFinish() ti = time.time() #prepare rendering model gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() glu.gluOrtho2D(*screen_limits) # translate to position of left board and render gl.glTranslatef(xTranslateLeft, yTranslate, 0.0) if render_left: CB_left.render() render_left = False # translate to position of right board and render gl.glTranslatef(-xTranslateLeft + xTranslateRight, 0.0, 0.0) if render_right: CB_right.render() render_right = False #show the scene gl.glFinish() glut.glutSwapBuffers() # get time for later mean frame time calculation gl.glFinish() tf = time.time() render_time_list.append(tf - ti)
def figure(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glLoadIdentity() GL.glPushMatrix() GL.glRotatef(alpha, 0.0, 1.0, 0.0) GL.glRotatef(beta, 0.0, 0.0, 1.0) GL.glBindTexture(GL.GL_TEXTURE_2D, texture[0]) for i in range(n): GL.glBegin(GL.GL_QUAD_STRIP) for j in range(m): x, y, z, s, t = f(i,j) GL.glTexCoord2f(s, t) GL.glVertex3f(x,y,z) x, y, z, s, t = f(i+1, j) GL.glTexCoord2f(s, t) GL.glVertex3f(x,y,z) GL.glEnd() GL.glPopMatrix() GLUT.glutSwapBuffers()
def display(self): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glLoadIdentity() # do zoom glu.gluLookAt(0.0, 0.0, self.zoom, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) # do rotation for x_rot, y_rot in reversed(self.rotations): gl.glRotatef(math.sqrt(x_rot**2 + y_rot**2), y_rot, x_rot, 0) #gl.glRotate(x_rot, 0, 1, 0) #gl.glRotate(y_rot, 1, 0, 0) """ one, two, three, four = (1, 1, 0), (1, -1, 0), (-1, -1, 0), (-1, 1, 0) draw_element(chemistry.elements[0], one) draw_single_bond(one, two) draw_element(chemistry.elements[0], two) draw_double_bond(two, three) draw_element(chemistry.elements[0], three) draw_triple_bond(three, four) draw_element(chemistry.elements[0], four) draw_quadruple_bond(four, one) """ #self.draw_atoms(self.molecule) gl.glCallList(self.displist) #gl.glFlush() glut.glutSwapBuffers()
def on_display(): global shader gl.glClearColor(1, 1, 1, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) radius = 255.0 theta, dtheta = 0, 5.5 / 180.0 * math.pi thickness = 1.0 support = .75 for i in range(500): xc, yc = 256, 256 + 32 r = 10.1 - i * 0.02 thickness = 1.0 #0.1 + (1.0-i/500.0)*4 x0 = xc + np.cos(theta) * radius * .925 y0 = yc + np.sin(theta) * radius * .925 x1 = xc + np.cos(theta) * radius * 1.00 y1 = yc + np.sin(theta) * radius * 1.00 line((x0, y0), (x1, y1), thickness, support) radius -= 0.45 theta += dtheta for i in range(0, 49): thickness = (i + 1) / 10.0 x = 20 + i * 10 + .315 y = 16 + .315 line((x, y + 6), (x, y - 6), thickness, support) glut.glutSwapBuffers()
def display(self): with self.mainfbo: self.clear() self.render() gl.glMemoryBarrier(gl.GL_FRAMEBUFFER_BARRIER_BIT) if self.emulate: gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, int(self.screenWidth / 2), self.screenHeight) self.tree.render(0) gl.glViewport(int(self.screenWidth / 2), 0, int(self.screenWidth / 2), self.screenHeight) self.texquad.render() else: gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) if self.preview: self.texquad.render() else: self.signalgenerator.render() glut.glutSwapBuffers() glut.glutPostRedisplay()
def render(drawings_list: List[Drawing]) -> None: """ Draw all sprites :param drawings_list: List of sprites to draw :return: """ gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) extended_drawings_list = [] drawings_queue = Queue() for drawing in drawings_list: extended_drawings_list.append(drawing) for child in drawing.get_child_sprites(): drawings_queue.put(child) while drawings_queue.qsize() > 0: drawing = drawings_queue.get() extended_drawings_list.append(drawing) for child in drawing.get_child_sprites(): drawings_queue.put(child) sorted_drawings_list = sorted(extended_drawings_list, key=lambda x: x.position[2]) for drawing in sorted_drawings_list: drawing.render() gl.glFlush() glut.glutSwapBuffers()
def display(): global args, mainfbo, texquad, signalgenerator with mainfbo: clear() t = reltime() effect.render(t) if args.emulate: gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, int(screenWidth / 2), screenHeight) tree.render(reltime()) gl.glViewport(int(screenWidth / 2), 0, int(screenWidth / 2), screenHeight) texquad.render() else: gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) if args.preview: texquad.render() else: signalgenerator.render() glut.glutSwapBuffers() glut.glutPostRedisplay()
def render(self): """The display callback function.""" self.frame_count += 1 GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.do_render() GLUT.glutSwapBuffers()
def Display (): global angle gl.glMatrixMode(gl.GL_MODELVIEW) #Borramos la escena gl.glClear (gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #Dibuja taza gl.glPushMatrix() gl.glColor3f (1.0, 1.0, 1.0) gl.glTranslatef(0.0,0.0,-1.0) gl.glRotatef(angle,0.0,1.0,0.0) glut.glutSolidTeapot(0.3) gl.glPopMatrix() #Dibuja Cubo gl.glPushMatrix() gl.glColor3f (0.0, 1.0, 0.0) gl.glTranslatef(0.0,0.0,-4.0) gl.glRotatef(angle,0.0,1.0,0.0) #gl.glRotatef(angle,0.0,1.0,0.0) gl.glTranslatef(1.0,0.0,0.0) glut.glutSolidCube(0.1) gl.glPopMatrix() glut.glutSwapBuffers() gl.glFlush()
def draw(): """skeleton function""" gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #clear screen gl.glLoadIdentity() #reset postition glut.glutSwapBuffers() #allows doouble buffering
def display(): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) program.draw(gl.GL_TRIANGLES, indices) glut.glutSwapBuffers() # Take screenshot in every display() screenshot()
def on_display( ): gl.glClearColor(1,1,1,1) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) global t, t0, frames t = glut.glutGet( glut.GLUT_ELAPSED_TIME ) frames = frames + 1 if t-t0 > 2500: print "FPS : %.2f (%d frames in %.2f second)" % (frames*1000.0/(t-t0), frames, (t-t0)/1000.0) t0, frames = t,0 shader.bind() shader.uniformi( 'texture', 0) shader.uniformf( 'size', w,h) shader.uniformf( 'major_grid_width', major_grid_width ) shader.uniformf( 'minor_grid_width', minor_grid_width ) shader.uniformf( 'major_grid_color', *major_grid_color ) shader.uniformf( 'minor_grid_color', *minor_grid_color ) shader.uniformf( 'major_tick_size', *major_tick_size ) shader.uniformf( 'minor_tick_size', *minor_tick_size ) shader.uniformf( 'major_tick_width', major_tick_width ) shader.uniformf( 'minor_tick_width', minor_tick_width ) shader.uniformf( 'major_tick_color', *major_tick_color ) shader.uniformf( 'minor_tick_color', *minor_tick_color ) axis.draw( gl.GL_TRIANGLES ) shader.unbind() glut.glutSwapBuffers()
def figure(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glLoadIdentity() GL.glPushMatrix() GL.glTranslatef(dX, dY, dZ) GL.glRotatef(a, 0.0, 1.0, 0.0) GL.glRotatef(b, 0.0, 0.0, 1.0) GL.glBindTexture(GL.GL_TEXTURE_2D, textura[0]) GL.glBegin(GL.GL_QUADS) GL.glTexCoord2f(0.0, 0.0) GL.glVertex3f(-1.0, -1.0, 1.0) GL.glTexCoord2f(1 / 3, 0.0) GL.glVertex3f(1.0, -1.0, 1.0) GL.glTexCoord2f(1 / 3, 1 / 2) GL.glVertex3f(1.0, 1.0, 1.0) GL.glTexCoord2f(0.0, 1 / 2) GL.glVertex3f(-1.0, 1.0, 1.0) GL.glTexCoord2f(2 / 3, 1 / 2) GL.glVertex3f(-1.0, -1.0, -1.0) GL.glTexCoord2f(1.0, 1 / 2) GL.glVertex3f(-1.0, 1.0, -1.0) GL.glTexCoord2f(1.0, 1.0) GL.glVertex3f(1.0, 1.0, -1.0) GL.glTexCoord2f(2 / 3, 1.0) GL.glVertex3f(1.0, -1.0, -1.0) GL.glTexCoord2f(1 / 3, 1 / 2) GL.glVertex3f(-1.0, 1.0, -1.0) GL.glTexCoord2f(2 / 3, 1 / 2) GL.glVertex3f(-1.0, 1.0, 1.0) GL.glTexCoord2f(2 / 3, 1) GL.glVertex3f(1.0, 1.0, 1.0) GL.glTexCoord2f(1 / 3, 1) GL.glVertex3f(1.0, 1.0, -1.0) GL.glTexCoord2f(1 / 3, 0.0) GL.glVertex3f(-1.0, -1.0, -1.0) GL.glTexCoord2f(2 / 3, 0.0) GL.glVertex3f(1.0, -1.0, -1.0) GL.glTexCoord2f(2 / 3, 1 / 2) GL.glVertex3f(1.0, -1.0, 1.0) GL.glTexCoord2f(1 / 3, 1 / 2) GL.glVertex3f(-1.0, -1.0, 1.0) GL.glTexCoord2f(0.0, 1 / 2) GL.glVertex3f(1.0, -1.0, -1.0) GL.glTexCoord2f(1 / 3, 1 / 2) GL.glVertex3f(1.0, 1.0, -1.0) GL.glTexCoord2f(1 / 3, 1.0) GL.glVertex3f(1.0, 1.0, 1.0) GL.glTexCoord2f(0.0, 1.0) GL.glVertex3f(1.0, -1.0, 1.0) GL.glTexCoord2f(2 / 3, 0.0) GL.glVertex3f(-1.0, -1.0, -1.0) GL.glTexCoord2f(1.0, 0.0) GL.glVertex3f(-1.0, -1.0, 1.0) GL.glTexCoord2f(1.0, 1 / 2) GL.glVertex3f(-1.0, 1.0, 1.0) GL.glTexCoord2f(2 / 3, 1 / 2) GL.glVertex3f(-1.0, 1.0, -1.0) GL.glEnd() GL.glPopMatrix() GLUT.glutSwapBuffers()
def draw_func(): #Clear the current buffer GL.glFlush() GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) # Render stuff f(self) # Load the identity matrix GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() #Transform the view in the appropriate way if self._dim == 3: GL.glTranslatef(0.,0.,-2) GL.glTranslatef(self._translate[0], self._translate[1], self._translate[2]) GL.glRotatef(self._rotate[0], 1, 0, 0) GL.glRotatef(self._rotate[1], 0, 1, 0) else: GL.glTranslatef(0.,0.,0.) GL.glTranslatef(self._translate[0], self._translate[1],0.0) GL.glRotatef(self._rotate[0], 0, 0, 1) GL.glRotatef(self._rotate[1], 0, 0, 1) # Scale GL.glScale(self._scale,self._scale,self._scale) #More niceness GL.glShadeModel(GL.GL_SMOOTH) # Swap out the new rendering. GLUT.glutSwapBuffers()
def display(): global phi, theta gl.glDepthMask(gl.GL_TRUE) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # Filled cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"]) gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT, None) # Outlined cube gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, 0.5) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"]) gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None) gl.glDepthMask(gl.GL_TRUE) # Rotate cube theta += 0.5 # degrees phi += 0.5 # degrees model = np.eye(4, dtype=np.float32) rotate(model, theta, 0, 0, 1) rotate(model, phi, 0, 1, 0) gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model) glut.glutSwapBuffers()
def on_display( ): global shader gl.glClearColor(1,1,1,1) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) radius = 255.0 theta, dtheta = 0, 5.5/180.0*math.pi thickness = 1.0 support = .75 for i in range(500): xc, yc = 256, 256+32 r = 10.1-i*0.02 thickness = 1.0 #0.1 + (1.0-i/500.0)*4 x0 = xc + np.cos(theta)*radius*.925 y0 = yc + np.sin(theta)*radius*.925 x1 = xc + np.cos(theta)*radius*1.00 y1 = yc + np.sin(theta)*radius*1.00 line( (x0,y0), (x1,y1), thickness, support) radius -= 0.45 theta += dtheta for i in range(0,49): thickness = (i+1)/10.0 x = 20+i*10 + .315 y = 16+.315 line( (x,y+6), (x,y-6), thickness, support ) glut.glutSwapBuffers()
def draw(): global alpha, left_button, right_button GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) figure() alpha = alpha + delta_alpha GLUT.glutSwapBuffers()
def display(): global projection, view gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glDisable( gl.GL_BLEND ) gl.glEnable( gl.GL_DEPTH_TEST ) gl.glEnable( gl.GL_POLYGON_OFFSET_FILL ) cubes.uniforms['rotate'][:,1] += 0.05 cubes.uniforms['rotate'][:,2] += 0.05 cubes.upload_uniforms() cubes.draw(gl.GL_TRIANGLES, {'u_projection' : projection, 'u_view' : view, 'u_color' : (1.0,1.0,1.0,1.0) } ) gl.glDisable( gl.GL_POLYGON_OFFSET_FILL ) gl.glEnable( gl.GL_BLEND ); gl.glDepthMask( gl.GL_FALSE ); outlines.uniforms['rotate'][:,1] += 0.05 outlines.uniforms['rotate'][:,2] += 0.05 outlines.upload_uniforms() outlines.draw(gl.GL_LINES, {'u_projection' : projection, 'u_view' : view, 'u_color' : (0.0,0.0,0.0,0.5) } ) gl.glDepthMask( gl.GL_TRUE ) glut.glutSwapBuffers()
def display(): update_from_http_control() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) camera() gl.glTranslate(cam_x, cam_y, cam_z) sphere() glut.glutSwapBuffers()
def Display(): global angle gl.glMatrixMode(gl.GL_MODELVIEW) #Borramos la escena gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #Dibuja taza gl.glPushMatrix() gl.glColor3f(1.0, 1.0, 1.0) gl.glTranslatef(0.0, 0.0, -1.0) gl.glRotatef(angle, 0.0, 1.0, 0.0) glut.glutSolidTeapot(0.3) gl.glPopMatrix() #Dibuja Cubo gl.glPushMatrix() gl.glColor3f(0.0, 1.0, 0.0) gl.glTranslatef(0.0, 0.0, -4.0) gl.glRotatef(angle, 0.0, 1.0, 0.0) #gl.glRotatef(angle,0.0,1.0,0.0) gl.glTranslatef(1.0, 0.0, 0.0) glut.glutSolidCube(0.1) gl.glPopMatrix() glut.glutSwapBuffers() gl.glFlush()
def display(): CAMERA.render() gl.glClear(gl.GL_COLOR_BUFFER_BIT) nonlocal scale scale_location = gl.glGetUniformLocation(program, "gScale") assert scale_location != 0xffffffff world_location = gl.glGetUniformLocation(program, "gWorld") assert world_location != 0xffffffff scale += 0.01 pipeline = Pipeline( rotation=[0.0, 30 * scale, 0.0], # scaling=[math.sin(scale)] * 3, translation=[0, 0, 6], projection=ProjParams(WINDOW_WIDTH, WINDOW_HEIGHT, 1.0, 100.0, 60.0)) pipeline.set_camera(CAMERA) gl.glUniformMatrix4fv(world_location, 1, gl.GL_TRUE, pipeline.get_wvp()) gl.glDrawElements(gl.GL_TRIANGLES, 18, gl.GL_UNSIGNED_INT, ctypes.c_void_p(0)) glut.glutSwapBuffers()
def render(self): """ Render the scene using the sphere display list """ if self.do_exit: print('renderer exiting ...') # glut event loop needs hard exit ... sys.exit(0) if self.bodies is None: time.sleep(1 / self.fps) return GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() x_size = GLUT.glutGet(GLUT.GLUT_WINDOW_WIDTH) y_size = GLUT.glutGet(GLUT.GLUT_WINDOW_HEIGHT) GLU.gluPerspective(60, float(x_size) / float(y_size), 0.05, 10) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glTranslatef(-_CAMERA_POSITION[0], -_CAMERA_POSITION[1], -_CAMERA_POSITION[2]) self.mouse_interactor.apply_transformation() for body_index in range(self.bodies.shape[0]): body = self.bodies[body_index, :] GL.glPushMatrix() GL.glTranslatef(body[0], body[1], body[2]) GL.glScalef(body[3], body[3], body[3]) GL.glCallList(self.sphere) GL.glPopMatrix() GLUT.glutSwapBuffers()
def draw(self): """The OpenGL draw routine.""" # sys.stderr.write("Start GLUTContext.draw\n") GL.glClearColor(self.background_color[0], self.background_color[1], self.background_color[2], self.background_color[3]) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glEnable(GL.GL_DEPTH_TEST) # sys.stderr.write("About to draw collections\n") for collection in self.object_collections: collection.draw() err = GL.glGetError() if err != GL.GL_NO_ERROR: sys.stderr.write("Error {} drawing: {}\n".format( err, gluErrorString(err))) sys.exit(-1) GLUT.glutSwapBuffers() # sys.stderr.write("Done drawing collections.\n") Rater.get().set() # sys.stderr.write("End GLUTContext.draw\n") self.framecount += 1
def __display(self): self.setSky(self.__Daytime) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) if self.__enableCamera == True: self.__do_movement() view = self.__camera.get_view_matrix() glUniformMatrix4fv(self.view_loc, 1, GL_FALSE, view) for element in self.__ElementsList: if isinstance(element, DayNightTimeBase): element.setDaytime(self.__Daytime) glUniform1i(self.switcher_loc, 0) if isinstance(element, DaytimeBase): if self.__Daytime == True: element.draw() elif isinstance(element, NighttimeBase): if self.__Daytime == False: element.draw() else: element.draw() glut.glutSwapBuffers()
def display(): #zadane tocke grupiraju se u grupe po 4 i tumace kao vrhovi cetverokuta koje treba nacrtati gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( 1.0,-1.0) gl.glColor3f(1,1,0); gl.glVertex2f(-1.0,-1.0) gl.glColor3f(1,1,1); gl.glVertex2f(-1.0, 1.0) gl.glColor3f(1,0,1); gl.glVertex2f( 1.0, 1.0) gl.glEnd() gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( -0.85,0.85) gl.glColor3f(1,1,1); gl.glVertex2f(0.85,0.85) gl.glColor3f(0,1,1); gl.glVertex2f(0.85, -0.85) gl.glColor3f(0,1,0); gl.glVertex2f( -0.85, -0.85) gl.glEnd() gl.glBegin(gl.GL_QUADS) gl.glColor3f(0,1,1); gl.glVertex2f( 0.5,-0.5) gl.glColor3f(1,0,1); gl.glVertex2f(-0.5,-0.5) gl.glColor3f(1,1,1); gl.glVertex2f(-0.5, 0.5) gl.glColor3f(1,0,0); gl.glVertex2f( 0.5, 0.5) gl.glEnd() glut.glutSwapBuffers()
def display(): simulation_start = timeit.default_timer() simulation.step() # simulation_end = timeit.default_timer() # render_start = timeit.default_timer() for k, p in enumerate(simulation.particles): particle_position[k, 0] = p.position.x particle_position[k, 1] = p.position.y loc = gl.glGetUniformLocation(program, "particle_pos") gl.glUniform2fv(loc, particle_count, particle_position) loc = gl.glGetUniformLocation(program, "resolution") gl.glUniform2f(loc, float(screen_x), float(screen_y)) loc = gl.glGetUniformLocation(program, "particle_bouding_radius") gl.glUniform1f(loc, float(simulation.box_radius)) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) glut.glutSwapBuffers() render_end = timeit.default_timer() fps_counter.append(1.0 / (render_end - simulation_start))
def display(): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glClearColor(1,0,1,0) gl.glBegin(gl.GL_QUADS) gl.glColor3f(1,0,0); gl.glVertex2f( 0.9,-0.9) gl.glColor3f(1,1,0); gl.glVertex2f(-0.9,-0.9) gl.glColor3f(1,1,1); gl.glVertex2f(-0.9, 0.9) gl.glColor3f(1,0,0); gl.glVertex2f( 0.9, 0.9) gl.glEnd() gl.glBegin(gl.GL_TRIANGLES) gl.glColor3f(1,0,0,1) gl.glVertex2f(-0.5,-0.5) gl.glColor3f(1,0,0,1) gl.glVertex2f(0.5,-0.5) gl.glColor3f(1,0,1,1) gl.glVertex2f(0.0,0.5) gl.glEnd() glut.glutSwapBuffers()
def display(): global projection, view global theta, phi theta += .43 phi += .37 gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) model = np.eye(4, dtype=np.float32) rotate(model, theta, 0,0,1) rotate(model, phi, 0,1,0) shader.bind() shader.uniformf('u_color', 1.0, 1.0, 1.0, 1.0 ) shader.uniform_matrixf('u_view', view) shader.uniform_matrixf('u_projection', projection) shader.uniform_matrixf('u_model', model) gl.glDisable( gl.GL_BLEND ) gl.glEnable( gl.GL_DEPTH_TEST ) gl.glEnable( gl.GL_POLYGON_OFFSET_FILL ) obj.draw( gl.GL_TRIANGLES ) gl.glDisable( gl.GL_POLYGON_OFFSET_FILL ) gl.glEnable( gl.GL_BLEND ); gl.glDepthMask( gl.GL_FALSE ); shader.uniformf('u_color', 0.0, 0.0, 0.0, 0.25 ) outline.draw( gl.GL_LINES ) gl.glDepthMask( gl.GL_TRUE ) gl.glUseProgram( 0 ) glut.glutSwapBuffers()
def tick(self, idle=None): now = time.time() if self.clock is not None: self.elapsed = now - self.clock self.clock = now if (idle and self.state and self.state != self.last_save_state and self.last_update_time and self.clock > self.last_update_time + UPDATE_DELAY_SECONDS): self.save_state() if self.elapsed is not None and self.anim_t is not None: last_t = self.anim_t self.anim_t -= self.elapsed / self.anim_duration self.anim_t = max(0, self.anim_t) anim_te = pow(self.anim_t, self.anim_ease) last_te = pow(last_t, self.anim_ease) self.anim_d = (last_te - anim_te) / last_te if self.anim_t == 0: self.anim_t = None self.update_state() self.anim_camera() self.anim_explode() self.clear() self.render_3d_lines() self.render_2d_hud() GLUT.glutSwapBuffers()
def display(): global projection, view global theta, phi theta += .43 phi += .37 gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) model = np.eye(4, dtype=np.float32) rotate(model, theta, 0, 0, 1) rotate(model, phi, 0, 1, 0) shader.bind() shader.uniformf('u_color', 1.0, 1.0, 1.0, 1.0) shader.uniform_matrixf('u_view', view) shader.uniform_matrixf('u_projection', projection) shader.uniform_matrixf('u_model', model) gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) obj.draw(gl.GL_TRIANGLES) gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) shader.uniformf('u_color', 0.0, 0.0, 0.0, 0.25) outline.draw(gl.GL_LINES) gl.glDepthMask(gl.GL_TRUE) gl.glUseProgram(0) glut.glutSwapBuffers()
def __glDraw(self): gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glClear(gl.GL_COLOR_BUFFER_BIT) width = glut.glutGet(glut.GLUT_WINDOW_WIDTH) height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT) if width == 0: return wh = width * 1.0 / height ctime = float(time.time()) - float(self.initTime) gl.glUniformMatrix2fv(self.timeloc, 1, False, [ctime, 0.0, 0.0, ctime]) for varIndex, varValue in self.fractalSettings.vars.items(): cValue = [varValue, 0.0, 0.0, varValue] gl.glUniformMatrix2fv(self.varloc[varIndex], 1, False, cValue) st = self.fractalSettings vertexAttrib = [st.center[0], st.center[1], st.scale, wh] gl.glVertexAttrib4f(1, *vertexAttrib) gl.glBegin(gl.GL_TRIANGLE_FAN) gl.glVertex2f(-1, -1) gl.glVertex2f(-1, 1) gl.glVertex2f(1, 1) gl.glVertex2f(1, -1) gl.glEnd() gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) glut.glutSwapBuffers()
def onDrawGL(): global g_yaw, g_pitch, g_translation_offset GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) # test GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() #g_yaw+=0.05 #g_pitch+=0.05 GL.glTranslatef(0.0, 0.0, -g_translation_offset) GL.glRotatef(g_yaw, 0, 1, 0) #GL.glRotatef(g_pitch, 1, 0, 0) #GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_POINT) #GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE) for i, renderable in enumerate(g_renderables): if g_active_renderable >= 0 and g_active_renderable != i: continue if renderable["type"] == "trimesh": draw_tri_mesh(renderable["vertices"], renderable["normals"], renderable["indices"]) elif renderable["type"] == "points": draw_points(renderable["positions"]) elif renderable["type"] == "lines": draw_lines(renderable["positions"]) GL.glFlush() GLUT.glutSwapBuffers()
def DrawGLScene(): global xrot, yrot, zrot, scale, xdist, ydist, zdist, light # Clear The Screen And The Depth Buffer GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) # Reset The View GL.glLoadIdentity() # Move Into The Screen GL.glTranslatef(xdist, ydist, zdist) # Rotate The Cube GL.glRotatef(xrot, 1.0, 0.0, 0.0) GL.glRotatef(yrot, 0.0, 1.0, 0.0) GL.glRotatef(zrot, 0.0, 0.0, 1.0) GL.glScalef(scale, scale, scale) if light: GL.glEnable(GL.GL_LIGHTING) else: GL.glDisable(GL.GL_LIGHTING) if _DrawCurrentSceneFunc: _DrawCurrentSceneFunc() # Since this is double buffered, swap the buffers to display what just got # drawn. GLUT.glutSwapBuffers()
def save(display_func, filename="screenshot.png"): """ """ try: import OpenGL.GL.EXT.framebuffer_object as fbo except ImportError: print 'You do not have the framebuffer extension on your video card' print 'Cannot save figure' return x, y, w, h = gl.glGetIntegerv(gl.GL_VIEWPORT) # Setup framebuffer framebuffer = fbo.glGenFramebuffersEXT(1) fbo.glBindFramebufferEXT(fbo.GL_FRAMEBUFFER_EXT, framebuffer) # Setup depthbuffer depthbuffer = fbo.glGenRenderbuffersEXT(1) fbo.glBindRenderbufferEXT(fbo.GL_RENDERBUFFER_EXT, depthbuffer) fbo.glRenderbufferStorageEXT(fbo.GL_RENDERBUFFER_EXT, gl.GL_DEPTH_COMPONENT, w, h) # Create texture to render to data = np.zeros((w, h, 4), dtype=np.ubyte) texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, w, h, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data) fbo.glFramebufferTexture2DEXT(gl.GL_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT, gl.GL_TEXTURE_2D, texture, 0) fbo.glFramebufferRenderbufferEXT(gl.GL_FRAMEBUFFER_EXT, gl.GL_DEPTH_ATTACHMENT_EXT, gl.GL_RENDERBUFFER_EXT, depthbuffer) status = fbo.glCheckFramebufferStatusEXT(fbo.GL_FRAMEBUFFER_EXT) if status != fbo.GL_FRAMEBUFFER_COMPLETE_EXT: raise (RuntimeError, 'Error in framebuffer activation') display_func() glut.glutSwapBuffers() data = gl.glReadPixels(x, y, w, h, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE) from PIL import Image image = Image.fromstring('RGBA', (w, h), data) image = image.transpose(Image.FLIP_TOP_BOTTOM) image.save(filename) # Cleanup fbo.glBindRenderbufferEXT(fbo.GL_RENDERBUFFER_EXT, 0) fbo.glBindFramebufferEXT(fbo.GL_FRAMEBUFFER_EXT, 0) gl.glDeleteTextures(texture) fbo.glDeleteFramebuffersEXT([ framebuffer, ])
def display(self): self.fps_frame += 1 self.fps_time = glut.glutGet(glut.GLUT_ELAPSED_TIME) if self.fps_time - self.fps_timebase > 1000: print('FPS:%4.2f' % (self.fps_frame * 1000.0 / (self.fps_time - self.fps_timebase))) self.fps_timebase = self.fps_time self.fps_frame = 0 gl.glClear(self.clear_bit) x, y, w, h = self.viewport gl.glMatrixMode(gl.GL_PROJECTION) gl.glLoadIdentity() if self.isperspect: fovy, aspect, zNear, zFar = self.glu_perspect #print fovy glu.gluPerspective(fovy, w / float(h), zNear, zFar) else: left, right, bottom, top, near, far = self.gl_orthog gl.glOrtho(left, right, bottom, top, near, far) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() eyex, eyey, eyez, centx, centy, centz, upx, upy, upz = self.glu_lookat glu.gluLookAt(eyex, eyey, eyez, centx, centy, centz, upx, upy, upz) self.mouse.applyTransformation() #Add objects self.plot.display() gl.glFlush() glut.glutSwapBuffers()
def render_routine(): global render_time_list # gl.glFinish() # t_initial = time.time() #prepare rendering model gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() glu.gluOrtho2D(*screen_limits) # translate to position of left board and render gl.glTranslatef(xTranslateLeft, yTranslate, 0.0) CB_left.render() # translate to position of right board and render gl.glTranslatef(-xTranslateLeft + xTranslateRight, 0.0, 0.0) CB_right.render() #show the scene gl.glFinish() glut.glutSwapBuffers() gl.glFinish() t_final = time.time() render_time_list.append(t_final)#t_final - t_initial)
def render(): # clear screen gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # reset camera gl.glLoadIdentity() # perform camera movement if necessary if deltaMove: computePos(deltaMove) # set up camera glu.gluLookAt(cam_pos_x, cam_pos_y, cam_pos_z, cam_pos_x + look_at_x, cam_pos_y + look_at_y, cam_pos_z + look_at_z, 0.0, 1.0, 0.0) # draw all bodies for body in bodies: body.draw() # draw all springs for s in springs: s.draw() blanket.draw() # redraw glut.glutSwapBuffers() glut.glutPostRedisplay()
def display(self): """ Render the scene. """ start = time.time() GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glPushMatrix() cam_x = self.zoom * math.sin(self.cam_lat) * math.cos(self.cam_long) cam_y = self.zoom * math.sin(self.cam_lat) * math.sin(self.cam_long) cam_z = self.zoom * math.cos(self.cam_lat) GLU.gluLookAt(cam_x, cam_y, cam_z, 0, 0, 0, 0, 0, 2) self.display_box() self.display_points() self.display_segments() self.display_circles() self.display_polygons() self.display_regions() self.display_sphere() GL.glPopMatrix() GLUT.glutSwapBuffers() render_time = time.time() - start GLUT.glutSetWindowTitle("%.3f" % render_time)
def display( self ): GL.glClearColor( 1.0, 1.0, 1.0, 1.0 ) GL.glClear( GL.GL_COLOR_BUFFER_BIT ) GL.glMatrixMode( GL.GL_PROJECTION ) GL.glLoadIdentity() GL.glOrtho( 0, self.width, 0, self.height, -1, 1 ) GL.glLineWidth(3) GL.glBegin( GL.GL_LINE_STRIP ) GL.glColor3f( 0.9, 0.3, 0.2 ) plen = max(int(1 / float(self.width) * len(self.points)), 1) for x in xrange(self.width): pstart = int(x / self.width * len(self.points)) prange = self.points[pstart:pstart + plen] # The log10(sqrt(prange) + 1.) part is totally ripped from Clementine. I don't # have any clue what it does, but it does make the thing look a whole lot nicer. # You do lose some detail because of it, though. # If you feel like explaining what the FHT::logSpectrum method defined in # <http://code.google.com/p/clementine-player/source/browse/src/core/fht.cpp> # actually does, drop me a mail at <*****@*****.**> - I'd appreciate it! GL.glVertex2i( x, int(max(log10(sqrt(prange) + 1.)) * self.height) ) GL.glEnd() GLUT.glutSwapBuffers() self.framecount += 1
def display(): global phi, theta gl.glDepthMask(gl.GL_TRUE) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # Filled cube gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) gl.glUniform4f(gpu["uniform"]["u_color"], 1, 1, 1, 1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["filled"]) gl.glDrawElements(gl.GL_TRIANGLES, len(f_indices), gl.GL_UNSIGNED_INT, None) # Outlined cube gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) gl.glEnable(gl.GL_BLEND) gl.glDepthMask(gl.GL_FALSE) gl.glUniform4f(gpu["uniform"]["u_color"], 0, 0, 0, .5) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, gpu["buffer"]["outline"]) gl.glDrawElements(gl.GL_LINES, len(o_indices), gl.GL_UNSIGNED_INT, None) gl.glDepthMask(gl.GL_TRUE) # Rotate cube theta += 0.5 # degrees phi += 0.5 # degrees model = np.eye(4, dtype=np.float32) rotate(model, theta, 0, 0, 1) rotate(model, phi, 0, 1, 0) gl.glUniformMatrix4fv(gpu["uniform"]["u_model"], 1, False, model) glut.glutSwapBuffers()
def display(self): gl.glClearColor(0.3, 0.5, 0.8, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glEnable(gl.GL_DEPTH_TEST) self.wm.camera.set_gl_camera() self.draw_func() glut.glutSwapBuffers()
def render(self): GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() self.world.render() GLUT.glutSwapBuffers()
def on_display( ): gl.glClearColor(1,1,1,1) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) grid.draw() collection.draw() glut.glutSwapBuffers()
def display(self): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glLoadIdentity() glu.gluLookAt(self.location[0], self.location[1], self.location[2], self.focus[0],self.focus[1], self.focus[2] , self.up[0], self.up[1], self.up[2]) self.draw_points(self.N) glut.glutSwapBuffers()
def save(display_func, filename="screenshot.png"): """ """ try: import OpenGL.GL.EXT.framebuffer_object as fbo except ImportError: print 'You do not have the framebuffer extension on your video card' print 'Cannot save figure' return x,y,w,h = gl.glGetIntegerv(gl.GL_VIEWPORT) # Setup framebuffer framebuffer = fbo.glGenFramebuffersEXT(1) fbo.glBindFramebufferEXT( fbo.GL_FRAMEBUFFER_EXT, framebuffer) # Setup depthbuffer depthbuffer = fbo.glGenRenderbuffersEXT( 1 ) fbo.glBindRenderbufferEXT( fbo.GL_RENDERBUFFER_EXT, depthbuffer ) fbo.glRenderbufferStorageEXT( fbo.GL_RENDERBUFFER_EXT, gl.GL_DEPTH_COMPONENT, w, h) # Create texture to render to data = np.zeros((w,h,4), dtype=np.ubyte) texture = gl.glGenTextures(1) gl.glBindTexture( gl.GL_TEXTURE_2D, texture) gl.glTexParameteri( gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameteri( gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexImage2D( gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, w, h, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data) fbo.glFramebufferTexture2DEXT( gl.GL_FRAMEBUFFER_EXT, gl.GL_COLOR_ATTACHMENT0_EXT, gl.GL_TEXTURE_2D, texture, 0) fbo.glFramebufferRenderbufferEXT( gl.GL_FRAMEBUFFER_EXT, gl.GL_DEPTH_ATTACHMENT_EXT, gl.GL_RENDERBUFFER_EXT, depthbuffer) status = fbo.glCheckFramebufferStatusEXT( fbo.GL_FRAMEBUFFER_EXT ) if status != fbo.GL_FRAMEBUFFER_COMPLETE_EXT: raise(RuntimeError, 'Error in framebuffer activation') display_func() glut.glutSwapBuffers() data = gl.glReadPixels (x,y,w,h, gl.GL_RGB, gl.GL_UNSIGNED_BYTE) from PIL import Image #from PIL.ImageCms import profileToProfile #ADOBE_RGB_PROFILE = "AdobeRGB1998.icc" #SRGB_PROFILE = "./sRGB.icc" #RGB_PROFILE = "./RGB.icc" image = Image.fromstring('RGB', (w,h), data) #profileToProfile(image, RGB_PROFILE, ADOBE_RGB_PROFILE, inPlace=1) image = image.transpose(Image.FLIP_TOP_BOTTOM) image.save (filename) # Cleanup fbo.glBindRenderbufferEXT( fbo.GL_RENDERBUFFER_EXT, 0 ) fbo.glBindFramebufferEXT( fbo.GL_FRAMEBUFFER_EXT, 0 ) gl.glDeleteTextures( texture ) fbo.glDeleteFramebuffersEXT( [framebuffer,] )
def DrawGLScene(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) #drawRotatingObjects() #setOrthoMode() drawBitsLUT() #setPerspectiveMode() GLUT.glutSwapBuffers()
def redraw(self): ''' The redraw() method invalidates the window area. Once the main loop becomes idle (after the current batch of events has been processed, roughly), the window will dispatch a ``draw`` event and swaps the buffers if double buffered. ''' self.dispatch_event('on_draw') # first redraw then swap buffers glut.glutSwapBuffers()
def display(): gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) #GL.glDepthFunc(gl.GL_LEQUAL) #gl.glDepthMask(gl.GL_TRUE) #gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 5) #gl.glDrawElements(gl.GL_TRIANGLES, len(Indices), gl.GL_UNSIGNED_INT, None) gl.glDrawElements(gl.GL_TRIANGLES, len(Indices), gl.GL_UNSIGNED_INT, ctypes.c_void_p(0)) glut.glutSwapBuffers()
def display(): gl.glClear(gl.GL_COLOR_BUFFER_BIT|gl.GL_DEPTH_BUFFER_BIT) gl.glPushMatrix() color = [1.0,0.5,0.5,1.] gl.glMaterialfv(gl.GL_FRONT,gl.GL_DIFFUSE,color) # glut.glutSolidSphere(2,20,20) glut.glutSolidTeapot(0.5) gl.glPopMatrix() glut.glutSwapBuffers() return