def draw_grid(self,): gl.glUseProgram(self.simple_object_shader) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) gl.glBindVertexArray(self.grid_vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo) vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection') vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition") vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor") vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera') gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function()) gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function()) gl.glEnableVertexAttribArray(vPosisition) gl.glEnableVertexAttribArray(vColor) gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None) gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4)) gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size // 4)
def display(self): """Draw surface to a quad. Call as part of OpenGL rendering code.""" ogl.glEnable(ogl.GL_BLEND) ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA) ogl.glEnable(ogl.GL_TEXTURE_2D) ogl.glBindTexture(ogl.GL_TEXTURE_2D, self._txtr) ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_REPLACE) #ogl.glColor4d( 1.0, 1.0, 1.0, alpha ) #ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_MODULATE) #glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); #ogl.glTexEnvfv(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_COLOR, (0, 0, 0, alpha)) #ogl.glNormal3f(0.0, 0.0, -1.0) ogl.glBegin(ogl.GL_QUADS) ogl.glTexCoord2f(0.0, 1-self._usable[1]) # bottom left corner ogl.glVertex3f(*self.dims[0]) ogl.glTexCoord2f(self._usable[0], 1-self._usable[1]) # bottom right corner ogl.glVertex3f(self.dims[1][0],self.dims[1][1],0.0) ogl.glTexCoord2f(self._usable[0], 1.0) # top right corner ogl.glVertex3f(*self.dims[2]) ogl.glTexCoord2f(0.0, 1.0) # top left corner ogl.glVertex3f(*self.dims[3]) ogl.glEnd() ogl.glDisable(ogl.GL_BLEND) ogl.glDisable(ogl.GL_TEXTURE_2D)
def gl_draw_all(self, root, offset): if not self.visible: return from OpenGL import GL, GLU rect = self.rect.move(offset) if self.is_gl_container: self.gl_draw_self(root, offset) suboffset = rect.topleft for subwidget in self.subwidgets: subwidget.gl_draw_all(root, suboffset) else: try: surface = Surface(self.size, SRCALPHA) except Exception: #size error? return self.draw_all(surface) data = image.tostring(surface, 'RGBA', 1) w, h = root.size GL.glViewport(0, 0, w, h) GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GLU.gluOrtho2D(0, w, 0, h) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glRasterPos2i(max(rect.left, 0), max(h - rect.bottom, 0)) 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.glDrawPixels(self.width, self.height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, fromstring(data, dtype='uint8')) GL.glPopAttrib() GL.glFlush()
def paintGL(self): """Handle paint event by drawing the items returned by the creator function.""" if not check_opengl_context(self.context(), (3, 0)): return program = self.shader_program projection = self.camera.projection(self.width(), self.height()) set_uniform_matrix(program, "view", self.camera.view_matrix) set_uniform_matrix(program, "projection", projection) set_uniform_vector(program, "ambient_color", self.ambient_color) set_uniform_vector(program, "diffuse_color", self.diffuse_color) set_uniform_vector(program, "diffuse_position", self.camera.position) GL.glClearColor(*self.background_color, 0) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_MULTISAMPLE) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) # Draw transparent items after opaque ones, and sorted by distance to # the observer (far to near). Note that this is only an approximation # that is correct only for point-like items; a 100% correct blending # order would have to be decided on the level of fragments (based on # the interpolated depth value). items = sorted( self.items, key=lambda item: ( item.opaque(), np.linalg.norm(self.camera.position - item.position()), ), reverse=True) for item in items: item.draw()
def display_one_track(self,track_index,color4=np.array([1,1,0,1],dtype=np.float32)): gl.glPushMatrix() gl.glDisable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LINE_SMOOTH) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA,gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_LINE_SMOOTH_HINT,gl.GL_DONT_CARE) gl.glLineWidth(7.) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glColor4fv(color4) d=self.data[track_index].astype(np.float32) gl.glVertexPointerf(d) gl.glDrawArrays(gl.GL_LINE_STRIP, 0, len(d)) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glEnable(gl.GL_LIGHTING) gl.glPopMatrix()
def initializeGL(self): self.cell_width = (2 * self.screen_width / len(self.game.field[0]) / self.screen_width) self.cell_height = (2 * self.screen_height / len(self.game.field) / self.screen_height) self.shader = Shader('shader.vs', 'shader.fs') self.shader.save_attr_locations(['aVertexPosition', 'aVertexTexCoord']) self.shader.save_uniform_locations(['uTexture']) self.shader.bind() GL.glEnable(GL.GL_DEPTH_TEST) GL.glClearColor(255, 255, 255, 1) GL.glViewport(0, 0, self.screen_width, self.screen_height) self.setGeometry(0, 0, self.screen_width, self.screen_height) self.set_field() self.start_spawn() self.draw_timer = Timer(self.update, consts.REDRAW_TIME) self.draw_timer.start_timer() GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
def initializeGL(self): """Init""" self.qglClearColor(self.gl_bg_color.darker()) #GL.glShadeModel(GL.GL_FLAT) GL.glEnable(GL.GL_DEPTH_TEST) GL.glClearDepth(1.0) #Fix up the lines to be cleaner... GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glLineWidth(0.1) GL.glEnable(GL.GL_BLEND) GL.glEnable(GL.GL_MULTISAMPLE) GL.glEnable(GL.GL_LIGHTING) GL.glEnable(GL.GL_LIGHT0) GL.glEnable(GL.GL_NORMALIZE) GL.glEnable(GL.GL_LIGHT1) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_COLOR_MATERIAL) GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, [0.6, 0.6, 0.6, 1.0]) GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, [0.3, 0.3, 0.3, 1.0]) GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SPECULAR, [0.5, 0.5, 0.5, 1.0]) GL.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 10.0) GL.glColorMaterial(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT_AND_DIFFUSE) GL.glLightModeli( GL.GL_LIGHT_MODEL_COLOR_CONTROL, GL.GL_SINGLE_COLOR ) GL.glLightModeli(GL.GL_LIGHT_MODEL_TWO_SIDE, 1)
def initGL(): gl.glShadeModel(gl.GL_SMOOTH) gl.glClearColor(1.0, 1.0, 1.0, 0.0) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glLightfv(gl.GL_LIGHT1, gl.GL_AMBIENT, [.1, .1, .1, .1]) gl.glLightfv(gl.GL_LIGHT1, gl.GL_DIFFUSE, [1., 1., 1., 0.]) gl.glLightfv(gl.GL_LIGHT1, gl.GL_SPECULAR, [1., 1., 1., 0.]) gl.glLightfv(gl.GL_LIGHT1, gl.GL_POSITION, [10., 5., 100., 1.]) gl.glEnable(gl.GL_LIGHT1) gl.glEnable(gl.GL_LIGHTING) gl.glCullFace(gl.GL_BACK) gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST) #gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glEnable(gl.GL_DITHER) gl.glEnable(gl.GL_CULL_FACE)
def initializeGL(self): # , width=1, height=1 """ Initialization of the GL frame. """ # TODO: glOrtho should set to size of the frame which would allow using # TODO: absolute coordinates in range/domain of original frame GL.glClearColor(0.0, 0.0, 0.0, 1.0) GL.glClearDepth(1.0) GL.glOrtho(0, 1, 1, 0, -1, 1) #glOrtho(0, width, height, 0, -1, 1) # DOESN'T WORK!! GL.glMatrixMode(GL.GL_PROJECTION) # Enable rational alpha blending GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) if self.anti_aliasing: # Points GL.glEnable(GL.GL_POINT_SMOOTH) GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST) # Lines GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) # Polygons, but NOT GL_TRIANGLE_FAN GL.glEnable(GL.GL_POLYGON_SMOOTH) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) # Not sure... GL.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST)
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 setDefaultParamsPoint(self, **params): params = super(PlotGL, self).setDefaultParamsPoint(**params) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glPointSize(params.get('point_size')) return params
def paintGL(self): GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GLU.gluLookAt(0, 0, 2, 0, 0, 0, 0, 1, 0) GL.glDisable(GL.GL_DEPTH_TEST) self.qglClearColor(self.clearColor) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glPushMatrix() GL.glEnable(GL.GL_TEXTURE_2D) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) offset = self.offset if offset <= 0: offset = 0 if offset > len(self.res_list) - 1: offset = len(self.res_list) - 1 mid = int(math.floor(offset + 0.5)) start_pos = mid - TileflowWidget.VISIBLE_TILES if start_pos < 0: start_pos = 0 end_pos = mid + TileflowWidget.VISIBLE_TILES if end_pos > len(self.res_list): end_pos = len(self.res_list) for i in range(start_pos, mid)[::TileflowWidget.DIRECTION]: self.drawTile(i, i - offset, self.tiles[i]) for i in range(mid, end_pos)[::-TileflowWidget.DIRECTION]: self.drawTile(i, i - offset, self.tiles[i]) GL.glPopMatrix()
def draw(self, P=None, V=None, M=None): atlas = self.font_manager.atlas if self._dirty: self.upload() gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_BLEND) _,_,width,height = gl.glGetIntegerv( gl.GL_VIEWPORT ) P = orthographic( 0, width, 0, height, -1, +1 ) V = np.eye(4).astype( np.float32 ) M = np.eye(4).astype( np.float32 ) shader = self.shader shader.bind() gl.glActiveTexture( gl.GL_TEXTURE0 ) shader.uniformi( 'u_uniforms', 0 ) gl.glBindTexture( gl.GL_TEXTURE_2D, self._ubuffer_id ) shape = self._ubuffer_shape shader.uniformf( 'u_uniforms_shape', shape[1]//4, shape[0]) gl.glActiveTexture( gl.GL_TEXTURE1 ) shader.uniformi( 'u_font_atlas', 1 ) shader.uniformf( 'u_font_atlas_shape', atlas.width, atlas.height, atlas.depth) gl.glBindTexture( gl.GL_TEXTURE_2D, self.font_manager.atlas.texid) shader.uniform_matrixf( 'u_M', M ) shader.uniform_matrixf( 'u_V', V ) shader.uniform_matrixf( 'u_P', P ) gl.glDisable( gl.GL_DEPTH_TEST ) self._vbuffer.draw( ) shader.unbind()
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) shader.bind() shader.uniformi( 'uniforms', 0 ) shape = collection.uniforms_shape or (1,1) shader.uniformf( 'uniforms_shape', shape[0], shape[1]) gl.glActiveTexture( gl.GL_TEXTURE0 ) gl.glBindTexture( gl.GL_TEXTURE_2D, collection.uniforms_id ) _,_,width,height = gl.glGetIntegerv( gl.GL_VIEWPORT ) P = orthographic( 0, width, 0, height, -1, +1 ) V = np.eye(4).astype( np.float32 ) M = np.eye(4).astype( np.float32 ) shader.uniform_matrixf( 'M', M ) shader.uniform_matrixf( 'V', V ) shader.uniform_matrixf( 'P', P ) collection.draw( ) shader.unbind() glut.glutSwapBuffers()
def _on_paint(self, event): """ Respond to paint events. Initialize GL if this is the first paint event. Resize the view port if the width or height changed. Redraw the screen, calling the draw functions. """ if not self.IsShownOnScreen(): # Cannot realise a GL context on OS X if window is not yet shown return # create device context (needed on Windows, noop on X) dc = None if event.GetEventObject(): # Only create DC if paint triggered by WM message (for OS X) dc = wx.PaintDC(self) self.lock() self.SetCurrent(self._gl_ctx) # Real the explicit GL context # check if gl was initialized if not self._gl_init_flag: GL.glClearColor(*BACKGROUND_COLOR_SPEC) for fcn in self._init_fcns: fcn() self._gl_init_flag = True # check for a change in window size if self._resized_flag: self.width, self.height = self.GetSize() GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GL.glOrtho(0, self.width, self.height, 0, 1, 0) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glViewport(0, 0, self.width, self.height) for cache in self._gl_caches: cache.changed(True) self._resized_flag = False # clear buffer if needed if self.clear_accum or not self.use_persistence: GL.glClear(GL.GL_COLOR_BUFFER_BIT) self.clear_accum=False # apply fading if self.use_persistence: GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glBegin(GL.GL_QUADS) GL.glColor4f(1,1,1,self.persist_alpha) GL.glVertex2f(0, self.height) GL.glVertex2f(self.width, self.height) GL.glVertex2f(self.width, 0) GL.glVertex2f(0, 0) GL.glEnd() GL.glDisable(GL.GL_BLEND) # draw functions for fcn in self._draw_fcns: fcn[1]() # show result self.SwapBuffers() self.unlock()
def draw_line(self, start_x, start_y, end_x, end_y, color=(1.0, 1.0, 1.0, 1.0), width=None): """Draw a line on canvas.""" gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() gl.glColor4f(*color) prev_width = None if width is not None: prev_width = gl.glGetFloat(gl.GL_LINE_WIDTH) gl.glLineWidth(width) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE) gl.glBegin(gl.GL_LINES) gl.glVertex2f(start_x, start_y) gl.glVertex2f(end_x, end_y) gl.glEnd() gl.glDisable(gl.GL_BLEND) if prev_width is not None: gl.glLineWidth(prev_width)
def enable_smoothing(): gl.glEnable(gl.GL_LINE_SMOOTH) gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glHint(gl.GL_POINT_SMOOTH_HINT, gl.GL_NICEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def init(self): """ For initialisation once OpenGL context is created. """ self.setAnimationPeriod(33) ogl.glDisable(ogl.GL_LIGHTING) ogl.glEnableClientState(ogl.GL_VERTEX_ARRAY) ogl.glEnable(ogl.GL_BLEND) ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA) ogl.glEnable(ogl.GL_CULL_FACE) ogl.glPointSize(2.0) self.setStateFileName('keyboard_anywhere.xml') if not self.restoreStateFromFile(): self.camera().setSceneRadius(500) # Make key commands appear in the help self.kbt = ['lower left', 'lower right', 'upper left'] self.setKeyDescription(QtCore.Qt.Key_1, 'set the {0} point of the keyboard'.format(self.kbt[0])) self.setKeyDescription(QtCore.Qt.Key_2, 'set the {0} point of the keyboard'.format(self.kbt[1])) self.setKeyDescription(QtCore.Qt.Key_3, 'set the {0} point of the keyboard'.format(self.kbt[2])) self.setKeyDescription(QtCore.Qt.Key_Z, 'shift the keyboard slightly in the local +Z direction') self.setKeyDescription(QtCore.Qt.ShiftModifier + QtCore.Qt.Key_Z, 'shift the keyboard slightly in the local -Z direction') self.setKeyDescription(QtCore.Qt.Key_Plus, 'rotate the keyboard slightly about the local +Y axis') self.setKeyDescription(QtCore.Qt.Key_Minus, 'rotate the keyboard slightly about the local -Y axis') self.kb_corners = np.zeros((3,3)) self.kb_corner_index = 0 self.keyboard = Keyboard()
def gl_draw_all(self, root, offset): if not self.visible: return from OpenGL import GL, GLU rect = self.rect.move(offset) if self.is_gl_container: self.gl_draw_self(root, offset) suboffset = rect.topleft for subwidget in self.subwidgets: subwidget.gl_draw_all(root, suboffset) else: try: surface = Surface(self.size, SRCALPHA) except Exception, e: #size error? return self.draw_all(surface) data = image.tostring(surface, 'RGBA', 1) w, h = root.size GL.glViewport(0, 0, w, h) GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GLU.gluOrtho2D(0, w, 0, h) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() GL.glRasterPos2i(max(rect.left, 0), max(h - rect.bottom, 0)) 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.glDrawPixels(self.width, self.height, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, fromstring(data, dtype='uint8')) GL.glPopAttrib() GL.glFlush()
def initializeGL(self): print('initializeGL') print(self.getOpenglInfo()) self.setClearColor(self.trolltechBlack) #self.object = self.makeObject() gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) # z - буфер gl.glEnable(gl.GL_LIGHTING) # включаем освещение gl.glEnable(gl.GL_LIGHT0) # включаем нулевую лампу gl.glEnable(gl.GL_COLOR_MATERIAL ) # управление свойством материала (отражение материала) #gl.glColorMaterial(gl.GL_FRONT, gl.GL_SPECULAR) gl.glEnable(gl.GL_NORMALIZE) # нормаль единичной длины gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, [100, 100, 100, 1]) # позиция нулевой лампы gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION, 0.1) # постоянная составляющая и расстояние gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION, 0.05) # линейная составляющая gl.glLightfv(gl.GL_LIGHT0, gl.GL_SPOT_DIRECTION, [0, 1, 1]) # положение источника света (ось конуса) gl.glLighti(gl.GL_LIGHT0, gl.GL_SPOT_EXPONENT, 0) gl.glLighti(gl.GL_LIGHT0, gl.GL_SPOT_CUTOFF, 5) # угол рассеяния луча gl.glShadeModel(gl.GL_SMOOTH) gl.glEnable(gl.GL_DEPTH_TEST) # включаем буфер глубины gl.glEnable(gl.GL_CULL_FACE)
def createShaders(self, parent): self._shaders.link() GL.glEnable(GL.GL_PROGRAM_POINT_SIZE) GL.glEnable(GL.GL_POINT_SPRITE) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnable(GL.GL_BLEND)
def __init__(self): super().__init__() self.initShaders() # location of model matrix in shader program self.modelview_loc = GL.glGetUniformLocation(self.shaderProgram, b"modelview") self.model_loc = GL.glGetUniformLocation(self.shaderProgram, b"model") self.projection_loc = GL.glGetUniformLocation(self.shaderProgram, b"projection") self.sampler_loc = GL.glGetUniformLocation(self.shaderProgram, b"sampler") # set background color to black GL.glClearColor(0.0, 0.0, 0.0, 1.0) # enable face culling (backface by default) GL.glEnable(GL.GL_CULL_FACE) GL.glEnable(GL.GL_DEPTH_TEST) # (Rs Sr + Rd Dr, Gs Sg + Gd Dg, Bs Sb + Bd Db, As Sa + Ad Da) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) self.window = GLWindow.getInstance() GL.glViewport(0, 0, window.size[0], window.size[1]) self.scene = Scene() self.scene.camera.setAspect(window.size[0], window.size[1])
def initializeGL(self): """Initialize OpenGL, VBOs, upload data on the GPU, etc.""" # First check for supported GL version gl_version = float(gl.glGetString(gl.GL_VERSION)[:3]) if gl_version < 3.3: return # background color gl.glClearColor(0, 0, 0, 0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # self.mcp_data = mcpUBO() self.globaldata = ndUBO() self.mcp_col_shader = BlueSkyProgram('mcp.vert', 'color.frag') self.mcp_tex_shader = BlueSkyProgram('mcp.vert', 'texture.frag') self.mcp_txt_shader = BlueSkyProgram('mcp_text.vert', 'mcp_text.frag') self.color_shader = BlueSkyProgram('normal.vert', 'color.frag') self.text_shader = BlueSkyProgram('text.vert', 'text.frag') self.text_shader.bind_uniform_buffer('global_data', self.globaldata) self.create_objects() self.update_lcd()
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) shader.bind() shader.uniformi('uniforms', 0) shape = collection.uniforms_shape or (1, 1) shader.uniformf('uniforms_shape', shape[0], shape[1]) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, collection.uniforms_id) _, _, width, height = gl.glGetIntegerv(gl.GL_VIEWPORT) P = orthographic(0, width, 0, height, -1, +1) V = np.eye(4).astype(np.float32) M = np.eye(4).astype(np.float32) shader.uniform_matrixf('M', M) shader.uniform_matrixf('V', V) shader.uniform_matrixf('P', P) collection.draw() shader.unbind() glut.glutSwapBuffers()
def paintLayer(self, layerName, width, height): self.width, self.height = width, height GL.glViewport(0, 0, self.width, self.height) self.qglClearColor(QtGui.QColor(0, 0, 200, 0)) GL.glHint(GL.GL_POINT_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST) GL.glEnable(GL.GL_POINT_SMOOTH) GL.glEnable(GL.GL_LINE_SMOOTH) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glMatrixMode(GL.GL_PROJECTION) # 2d operations GL.glLoadMatrixf(np.array([[self.camera.cameraZoom,0,0,0],[0,self.camera.cameraZoom,0,0],[0,0,1.0,0],[(2.0*self.camera.cameraOx)/self.width,(2.0*self.camera.cameraOy)/self.height,0,1.0]],dtype=np.float32)) # set the near and far clipping planes and aspect ratio # try to control the near and far based on the interest distance GL.glMultMatrixf(np.array([[1,0,0,0],[0,self.aspect,0,0],[0,0,-1.00002,-1],[0,0,self.camera.cameraInterest*-0.0200002,0]],dtype=np.float32)) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glShadeModel(GL.GL_SMOOTH) # draw 3D geometry # apply the camera matrix GL.glMatrixMode(GL.GL_PROJECTION) GL.glMultMatrixd(self.camera.P().T) GL.glMatrixMode(GL.GL_MODELVIEW) p = self.getLayer(layerName) if p is None: return p.paintGL(drawOpts=self.drawOpts)
def renderNeckMethod(self, visibility, offset, neck, alpha=False): #blazingamer: New neck rendering method v = visibility gl.glEnable(gl.GL_TEXTURE_2D) if offset == 0: board_tex = self.board_tex_static else: board_tex = self.board_tex if self.failcount == v: board_col = self.board_col_flash else: board_col = self.board_col if alpha == True: gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) if neck: neck.texture.bind() cmgl.drawArrays(gl.GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex) if alpha == True: gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDisable(gl.GL_TEXTURE_2D)
def render(self): if not self.isExposed(): return self.context.makeCurrent(self) bits = 0 bits |= gl.GL_COLOR_BUFFER_BIT bits |= gl.GL_DEPTH_BUFFER_BIT bits |= gl.GL_STENCIL_BUFFER_BIT gl.glClear(bits) gl.glEnable(gl.GL_PROGRAM_POINT_SIZE) for program in self.layer_manager.programs(): if program.do_blending: if self.bg_white: gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_SRC_ALPHA) else: gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_ONE, gl.GL_SRC_ALPHA) else: gl.glDisable(gl.GL_BLEND) self.layer_manager.draw() if self.hud_program.is_visible: self.hud_program.draw() self.context.swapBuffers(self)
def _execute_vbos(self): gl.glDisable(gl.GL_LIGHTING) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glLineWidth(self.line_width) self.vbo.bind() #try: gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) #gl.glVertexPointerf(cdata) gl.glVertexPointer(3, gl.GL_FLOAT, 28, self.vbo) gl.glColorPointer(4, gl.GL_FLOAT, 28, self.vbo + 12) gl.glMultiDrawArrays(gl.GL_LINE_STRIP,\ self.first,self.counts,self.len_counts) #finally: self.vbo.unbind() gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisable(gl.GL_BLEND) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_DEPTH_TEST)
def draw_text(self, text, color=(1.0, 1.0, 0.0, 0.0), screen_position=(0.0, 0.0)): import OpenGL.GL as gl gl.glUseProgram(self._program_id) gl.glActiveTexture(gl.GL_TEXTURE0 + self._texture_unit) gl.glBindTexture(gl.GL_TEXTURE_2D, self._texture_id) #gl.glBindSampler(tex_unit, self._sampler_id) gl.glUniform1i(self._uniform_locations['u_fonttex'], self._texture_unit) gl.glUniform4f(self._uniform_locations['u_color'], *color) gl.glUniform2f(self._uniform_locations['u_screen_size'], *self._screen_size) gl.glUniform2f(self._uniform_locations['u_char_size'], self._width, self._height) gl.glUniform2f(self._uniform_locations['u_screen_position'], *screen_position) gl.glUniform2f(self._uniform_locations['u_fonttex_size'], self._image_width, self._image_height) nchars = len(text) gl.glUniform1ui(self._uniform_locations['u_nchars'], nchars) self._texcoords[:nchars] = [self._char_to_texcoords[c] for c in text] gl.glUniform2fv(self._uniform_locations['u_texcoords'], nchars, self._texcoords) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) gl.glDisable(gl.GL_BLEND)
def GL_drawPath(self, x, y, mode=GL.GL_LINE_STRIP): points = np.empty((len(x), 2)) points[:, 0] = x points[:, 1] = y GL.glEnableClientState(GL.GL_VERTEX_ARRAY) try: GL.glVertexPointerf(points) if mode in (GL.GL_LINES, GL.GL_LINE_STRIP, GL.GL_LINE_LOOP): GL.glEnable(GL.GL_LINE_SMOOTH) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) color = self.pen.color() GL.glLineWidth(self.pen.width()) elif mode == GL.GL_TRIANGLE_FAN: color = self.brush.color() GL.glColor3f(color.red() / 255, color.green() / 255, color.blue() / 255) GL.glDrawArrays(mode, 0, points.shape[0]) finally: GL.glDisableClientState(GL.GL_VERTEX_ARRAY)
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 billboardLabel(self, objPos, character, offset, scale): GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glColor4f(self.textColour[0], self.textColour[1], self.textColour[2], 1.0) GL.glEnable(GL.GL_TEXTURE_2D) GL.glPushMatrix() GL.glTranslate(objPos[0], objPos[1], objPos[2]) modelview = (GL.GLfloat * 16)() mvm = GL.glGetFloatv(GL.GL_MODELVIEW_MATRIX, modelview) for i in (0, 1, 2): for j in (0, 1, 2): if i is j: modelview[i * 4 + j] = 1 else: modelview[i * 4 + j] = 0 GL.glLoadMatrixf(mvm) GL.glScalef(scale, scale, scale) GL.glTranslate(offset, 0, 0) GL.glCallList(self.fonts[character]) GL.glPopMatrix() GL.glDisable(GL.GL_TEXTURE_2D) GL.glDisable(GL.GL_BLEND)
def initialize_scene(): return gl.glClearColor(0, 1, 1, 1) gl.glColor3f(1, 1, 1) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE)
def paintGL(self): """Paint the scene. """ gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_POINT_SMOOTH) gl.glPointSize(10) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) #bind the color buffer self.glcolbuf.bind() gl.glColorPointer(4, gl.GL_FLOAT, 0, None) # bind the VBO self.glbuf.bind() # these vertices contain 2 simple precision coordinates gl.glVertexPointer(2, gl.GL_FLOAT, 0, None) # tell OpenGL that the VBO contains an array of vertices gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) # draw "count" points from the VBO gl.glDrawArrays(gl.GL_POINTS, 0, self.color_count) gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisable(gl.GL_BLEND)
def drawGrid(self): #draw grid # line smooth and alpha blending of the lines if self.bsmooth: GL.glEnable(GL.GL_LINE_SMOOTH) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST) GL.glBegin(GL.GL_LINES) xr = 200.0 zr = 200.0 dx = 10.0 dz = 10.0 xval = np.arange(-0.5 * xr, +0.5 * xr + dx * 0.001, dx) zval = np.arange( self.center_mass[self.lasti0 % self.nbframes] - 0.5 * zr, self.center_mass[self.lasti0 % self.nbframes] + 0.5 * zr + dz * 0.001, dz) GL.glColor4f(1.0, 1.0, 1.0, 0.3) for x in xval: GL.glVertex3f(zval[0], 0.0, x) GL.glVertex3f(zval[-1], 0.0, x) for z in zval: GL.glVertex3f(z, 0.0, xval[0]) GL.glVertex3f(z, 0.0, xval[-1]) GL.glEnd()
def _draw_selection_box(self): """ The drawing method for the selection box. Initially we will draw the box boundaries with lines, and then fill the interior with two triangles. IMPORTANT!!! THIS FUNCTION MUST BE CALLED ONLY WHEN AN OPENGL CONTEXT WINDOW HAS BEEN CREATED AND INITIALIZED, OTHERWISE WILL RAISE AN ERROR IN THE OPENGL WRAPPER!!! YOU HAVE BEEN WARNED """ GL.glUseProgram(self.selection_box_program) GL.glLineWidth(1) GL.glBindVertexArray(self.vao) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[1]) GL.glBufferData(GL.GL_ARRAY_BUFFER, self.points.itemsize*int(len(self.points)), self.points, GL.GL_DYNAMIC_DRAW) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[0]) GL.glBufferData(GL.GL_ARRAY_BUFFER, self.indexes.itemsize*int(len(self.indexes)), self.indexes, GL.GL_DYNAMIC_DRAW) GL.glDrawElements(GL.GL_LINE_STRIP, int(len(self.indexes)), GL.GL_UNSIGNED_INT, None) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_SRC_ALPHA) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self.buffers[0]) GL.glBufferData(GL.GL_ARRAY_BUFFER, self.triangles.itemsize*int(len(self.triangles)), self.triangles, GL.GL_DYNAMIC_DRAW) GL.glDrawElements(GL.GL_TRIANGLE_STRIP, int(len(self.triangles)), GL.GL_UNSIGNED_INT, None) GL.glDisable(GL.GL_BLEND) GL.glDisable(GL.GL_DEPTH_TEST) GL.glBindVertexArray(0) GL.glUseProgram(0) return True
def quad(self, g, quad): # Enable alpha blending/transparency self.vbuffer.sync() gl.glUseProgram(self.program.id) gl.glEnable(gl.GL_BLEND) gl.glEnable(gl.GL_DEPTH_TEST) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # Bind texture gl.glUniform1i(self.program.tex, 0) gl.glBindTexture(gl.GL_TEXTURE_2D, quad.texture.id) # Set up geometry transforms worldMatrix = Matrix.scale(quad.width, quad.height, 1) worldMatrix = Matrix.translate(quad.x, quad.y, 0) * worldMatrix worldViewProjectionMatrix = g.viewProjectionMatrix * worldMatrix #worldViewProjectionMatrix = g.viewProjectionMatrix gl.glUniformMatrix4fv(self.program.worldViewProjectionMatrix, 1, 0, worldViewProjectionMatrix.data) # Draw geometry gl.glBindVertexArray(self.vao) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) gl.glBindVertexArray(0)
def __init__(self, joints_3d, skeleton): super().__init__('Pose viewer', 1600, 900, msaa=4) # Enable alpha blending. gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # Enable back-face culling. gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_BACK) # Enable depth test. gl.glEnable(gl.GL_DEPTH_TEST) self.shader = create_simple_shader() self.trans_mats_binding = UniformBinding('transformMatrices', [ ('viewMatrix', np.float32, (4, 4)), ('projMatrix', np.float32, (4, 4)), ]) self.trans_mats_binding.bind_program(self.shader) self.trans_mats_ubo = self.trans_mats_binding.create_ubo(bind=True) self.trans_mats_ubo['viewMatrix'] = np.eye(4) self.trans_mats_ubo['projMatrix'] = np.eye(4) self.reset_free_camera() self.skeleton = skeleton self.bones = self.pose_to_bones(joints_3d) self.origin = joints_3d[skeleton.root_joint_id]
def draw(self): 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(3, gl.GL_FLOAT, 0, self.vertices) gl.glColorPointer(4, gl.GL_FLOAT, 0, self.colors) gl.glTexCoordPointer(2, gl.GL_FLOAT, 0, self.texcoords) r,g,b = 0,0,0 gl.glColor( 1, 1, 1, 1 ) gl.glEnable( gl.GL_BLEND ) #gl.glBlendFunc( gl.GL_CONSTANT_COLOR_EXT, gl.GL_ONE_MINUS_SRC_COLOR ) #gl.glBlendColor(r,g,b,1) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) gl.glBlendColor( 1, 1, 1, 1 ) gl.glEnableVertexAttribArray( 1 ); gl.glVertexAttribPointer( 1, 1, gl.GL_FLOAT, gl.GL_FALSE, 0, self.attrib) shader.bind() shader.uniformi('texture', 0) shader.uniformf('pixel', 1.0/512, 1.0/512) gl.glDrawElements(gl.GL_TRIANGLES, len(self.indices), gl.GL_UNSIGNED_INT, self.indices) shader.unbind() gl.glDisableVertexAttribArray( 1 ); gl.glDisableClientState(gl.GL_VERTEX_ARRAY) gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY) gl.glDisable( gl.GL_TEXTURE_2D ) gl.glDisable( gl.GL_BLEND )
def display(self): """(Re)display all the actors in the scene. This should e.g. be used when actors are added to the scene, or after changing camera position/orientation or lens. """ #GD.debugt("UPDATING CURRENT OPENGL CANVAS") self.makeCurrent() self.clear() self.glLight(self.lighting) # draw the highlighted actors self.camera.loadProjection() self.camera.loadMatrix() if self.highlights: for actor in self.highlights: actor.draw(mode=self.rendermode) # draw the scene actors if self.alphablend: opaque = [ a for a in self.actors if not a.trans ] transp = [ a for a in self.actors if a.trans ] for actor in opaque: actor.draw(mode=self.rendermode) GL.glEnable (GL.GL_BLEND) GL.glDepthMask (GL.GL_FALSE) GL.glBlendFunc (GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) for actor in transp: actor.draw(mode=self.rendermode) GL.glDepthMask (GL.GL_TRUE) GL.glDisable (GL.GL_BLEND) else: for actor in self.actors: self.setDefaults() actor.draw(mode=self.rendermode) # annotations are drawn in 3D space for actor in self.annotations: self.setDefaults() actor.draw(mode=self.rendermode) # decorations are drawn in 2D mode self.begin_2D_drawing() if len(self.decorations) > 0: for actor in self.decorations: self.setDefaults() actor.draw(mode=self.rendermode) # draw the focus rectangle if more than one viewport if len(GD.GUI.viewports.all) > 1: if self.hasFocus(): self.draw_focus_rectangle(2) elif self.focus: self.draw_focus_rectangle(1) self.end_2D_drawing() # make sure canvas is updated GL.glFlush()
def renderNeckMethod(self, visibility, offset, neck, alpha = False): #blazingamer: New neck rendering method v = visibility gl.glEnable(gl.GL_TEXTURE_2D) if offset == 0: board_tex = self.board_tex_static else: board_tex = self.board_tex if self.failcount == v: board_col = self.board_col_flash else: board_col = self.board_col if alpha == True: gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE) if neck: neck.texture.bind() cmgl.drawArrays(gl.GL_TRIANGLE_STRIP, vertices=self.board_vtx, colors=board_col, texcoords=board_tex) if alpha == True: gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDisable(gl.GL_TEXTURE_2D)
def display(self): """Draw surface to a quad. Call as part of OpenGL rendering code.""" ogl.glEnable(ogl.GL_BLEND) ogl.glBlendFunc(ogl.GL_SRC_ALPHA, ogl.GL_ONE_MINUS_SRC_ALPHA) ogl.glEnable(ogl.GL_TEXTURE_2D) ogl.glBindTexture(ogl.GL_TEXTURE_2D, self._txtr) ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_REPLACE) #ogl.glColor4d( 1.0, 1.0, 1.0, alpha ) #ogl.glTexEnvf(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_MODE, ogl.GL_MODULATE) #glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); #ogl.glTexEnvfv(ogl.GL_TEXTURE_ENV, ogl.GL_TEXTURE_ENV_COLOR, (0, 0, 0, alpha)) #ogl.glNormal3f(0.0, 0.0, -1.0) ogl.glBegin(ogl.GL_QUADS) ogl.glTexCoord2f(0.0, 1 - self._usable[1]) # bottom left corner ogl.glVertex3f(*self.dims[0]) ogl.glTexCoord2f(self._usable[0], 1 - self._usable[1]) # bottom right corner ogl.glVertex3f(self.dims[1][0], self.dims[1][1], 0.0) ogl.glTexCoord2f(self._usable[0], 1.0) # top right corner ogl.glVertex3f(*self.dims[2]) ogl.glTexCoord2f(0.0, 1.0) # top left corner ogl.glVertex3f(*self.dims[3]) ogl.glEnd() ogl.glDisable(ogl.GL_BLEND) ogl.glDisable(ogl.GL_TEXTURE_2D)
def render(self, visibility): """ Render the layer. @param visibility: Floating point visibility factor (1 = opaque, 0 = invisibile) """ w, h = self.stage.engine.view.geometry[2:4] v = 1.0 - visibility ** 2 color = self.color #coordinates are positioned with (0,0) being in the middle of the screen coord = [w/2 + self.position[0] * w/2, h/2 - self.position[1] * h/2] if v > .01: color = [self.color[0], self.color[1], self.color[2], visibility] scale = [self.scale[0], -self.scale[1]] rot = self.angle self.transforms = [scale, coord, rot, color] # Blend in all the effects for effect in self.effects: effect.apply() gl.glBlendFunc(self.srcBlending, self.dstBlending) drawImage(self.drawing, self.transforms[0], self.transforms[1], self.transforms[2], self.transforms[3]) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
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 InitialiseOpenGL( self, width, height ) : # Initialise the trackball self.trackball = mtk.Trackball() self.trackball.Initialise( width, height ) # Default background color gl.glClearColor( 1, 1, 1, 1 ) # Enable depth test gl.glEnable( gl.GL_DEPTH_TEST ) # Enable face culling gl.glEnable( gl.GL_CULL_FACE ) # Enable blending function gl.glEnable( gl.GL_BLEND ) gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA ) # Enable multisampling (antialiasing) gl.glEnable( gl.GL_MULTISAMPLE ) # Initialise the projection transformation matrix self.SetProjectionMatrix( width, height ) # Initialise Model-View transformation matrix self.modelview_matrix = np.identity( 4, dtype=np.float32 ) # Position the scene (camera) self.modelview_matrix[3,2] = -30.0 # Load the shaders self.flat_shader = mtk.FlatShader() self.smooth_shader = mtk.SmoothShader() self.shader = self.smooth_shader # Initialise viewing parameters self.wireframe_mode = 0 self.element_number = 0 self.color_enabled = False self.antialiasing = True
def drawSphere(self) : if self._indexes is None : return GL.glDisable(GL.GL_CULL_FACE) # GL.glEnable(GL.GL_LIGHTING) # GL.glScale(1,1,1) # GL.glDisable(GL.GL_LIGHTING) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glEnableClientState( GL.GL_VERTEX_ARRAY ) GL.glEnableClientState( GL.GL_COLOR_ARRAY ) GL.glEnableClientState( GL.GL_NORMAL_ARRAY ) GL.glColorPointer( 4, GL.GL_FLOAT, 0, self._meshColors) GL.glVertexPointer( 3, GL.GL_FLOAT, 0, self._vertices ) GL.glNormalPointer( GL.GL_FLOAT, 0, self._normals ) GL.glDrawElements( GL.GL_TRIANGLE_STRIP, len(self._indexes), GL.GL_UNSIGNED_INT, self._indexes ) GL.glDisableClientState( GL.GL_COLOR_ARRAY ) GL.glColor(0.6,.3,.6) GL.glDrawElements( GL.GL_POINTS, len(self._indexes), GL.GL_UNSIGNED_INT, self._indexes ) GL.glDisableClientState( GL.GL_COLOR_ARRAY ) GL.glDisableClientState( GL.GL_VERTEX_ARRAY ) GL.glDisableClientState( GL.GL_NORMAL_ARRAY )
def initializeGL(self): """Initialize OpenGL, VBOs, upload data on the GPU, etc.""" # First check for supported GL version gl_version = float(gl.glGetString(gl.GL_VERSION)[:3]) if gl_version < 3.3: return # background color gl.glClearColor(0, 0, 0, 0) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.globaldata = ndUBO() try: # Compile shaders and link color shader program self.color_shader = BlueSkyProgram('data/graphics/shaders/nd-normal.vert', 'data/graphics/shaders/nd-color.frag') self.color_shader.bind_uniform_buffer('global_data', self.globaldata) # Compile shaders and link text shader program self.text_shader = BlueSkyProgram('data/graphics/shaders/nd-text.vert', 'data/graphics/shaders/nd-text.frag') self.text_shader.bind_uniform_buffer('global_data', self.globaldata) except RuntimeError as e: qCritical('Error compiling shaders in radarwidget: ' + e.args[0]) return # Set initial zoom self.globaldata.set_zoom(4.0) self.create_objects()
def _draw_point_label(self): """ Draw the point label for the last mouse motion coordinate. The mouse coordinate must be an X, Y tuple. The label will be drawn at the X, Y coordinate. The values of the X, Y coordinate will be scaled to the current X, Y bounds. """ if not self.enable_point_label(): return if not self._point_label_coordinate: return x, y = self._point_label_coordinate if x < self.padding_left or x > self.width-self.padding_right: return if y < self.padding_top or y > self.height-self.padding_bottom: return #scale to window bounds x_win_scalar = float(x - self.padding_left)/(self.width-self.padding_left-self.padding_right) y_win_scalar = float((self.height - y) - self.padding_bottom)/(self.height-self.padding_top-self.padding_bottom) #scale to grid bounds x_val = x_win_scalar*(self.x_max-self.x_min) + self.x_min y_val = y_win_scalar*(self.y_max-self.y_min) + self.y_min #create text label_str = self._populate_point_label(x_val, y_val) if not label_str: return txt = gltext.Text(label_str, font_size=POINT_LABEL_FONT_SIZE) w, h = txt.get_size() #enable transparency GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) #draw rect + text GL.glColor4f(*POINT_LABEL_COLOR_SPEC) if x > self.width/2: x -= w+2*POINT_LABEL_PADDING + POINT_LABEL_OFFSET else: x += POINT_LABEL_OFFSET self._draw_rect(x, y-h-2*POINT_LABEL_PADDING, w+2*POINT_LABEL_PADDING, h+2*POINT_LABEL_PADDING) txt.draw_text(wx.Point(x+POINT_LABEL_PADDING, y-h-POINT_LABEL_PADDING))
def display(self): gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glClearColor(*self.BACKGROUND) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glLoadIdentity() glu.gluLookAt(-0.75 * self.size, -0.75 * self.size, 1.75 * self.size, 0.5 * self.size, 0.5 * self.size, 0.5 * self.size, 0, 0, 1) # We want to rotate about the centre of the cube, so # shift, rotate, shift back gl.glTranslate(self.size / 2.0, self.size / 2.0, self.size / 2.0) gl.glRotatef(self.rx, 1, 0, 0) gl.glRotatef(self.ry, 0, 1, 0) gl.glRotatef(self.rz, 0, 0, 1) gl.glTranslate(-self.size / 2.0, -self.size / 2.0, -self.size / 2.0) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) gl.glEnableClientState(gl.GL_COLOR_ARRAY) gl.glVertexPointerf(self.verts) gl.glColorPointerf(self.colours) gl.glDrawArrays(gl.GL_TRIANGLES, 0, len(self.verts)) self._render_floor() gl.glDisableClientState(gl.GL_COLOR_ARRAY) gl.glDisableClientState(gl.GL_VERTEX_ARRAY)
def drawCharacterHead(self, x, y, z, realCoords=None, dim=0): GL.glEnable(GL.GL_CULL_FACE) origin = (x - 0.25, y - 0.25, z - 0.25) size = (0.5, 0.5, 0.5) box = FloatBox(origin, size) hat_origin = (x - 0.275, y - 0.275, z - 0.275) hat_size = (0.55, 0.55, 0.55) hat_box = FloatBox(hat_origin, hat_size) if realCoords is not None and self.playerPos[dim][ realCoords] != "Player" and config.settings.downloadPlayerSkins.get( ): drawCube( box, texture=self.playerTexture[self.playerPos[dim][realCoords]], textureVertices=self.texVerts[0]) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) drawCube( hat_box, texture=self.playerTexture[self.playerPos[dim][realCoords]], textureVertices=self.texVerts[1]) GL.glDisable(GL.GL_BLEND) else: drawCube(box, texture=self.charTex, textureVertices=self.texVerts[0]) GL.glDisable(GL.GL_CULL_FACE)
def draw_grid(self,): gl.glUseProgram(self.simple_object_shader) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) gl.glBindVertexArray(self.grid_vao) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.grid_vbo) vProjection = gl.glGetUniformLocation(self.simple_object_shader, 'vProjection') vPosisition = gl.glGetAttribLocation(self.simple_object_shader, "vPosisition") vColor = gl.glGetAttribLocation(self.simple_object_shader, "vColor") vCamera = gl.glGetUniformLocation(self.simple_object_shader, 'vCamera') gl.glUniformMatrix4fv(vProjection, 1, gl.GL_FALSE, self.projection_matrix_function()) gl.glUniformMatrix4fv(vCamera, 1, gl.GL_FALSE, self.camera_matrix_function()) gl.glEnableVertexAttribArray(vPosisition) gl.glEnableVertexAttribArray(vColor) gl.glVertexAttribPointer(vPosisition, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, None) gl.glVertexAttribPointer(vColor, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(self.grid_size * 4)) gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.grid_size / 4)