def prepare_rendering(self, render_option): if render_option.primitive == renderoption.Primitive.Point: gl.glPointSize(gl.GLfloat(render_option.point_size)) else: gl.glLineWidth(gl.GLfloat(render_option.line_width)) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GLenum(render_option.get_depth_func())) return True
def prepare_rendering(self, render_option): if render_option.primitive.Line: gl.glLineWidth(gl.GLfloat(2.0)) else: gl.glPointSize(gl.GLfloat(5.0)) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GLenum(gl.GL_LEQUAL)) return True
def render(self): """Handle all drawing operations.""" self.SetCurrent(self.context) if not self.init: # Configure the viewport, modelview and projection matrices self.init_gl() self.init = True # Clear everything GL.glClear(GL.GL_COLOR_BUFFER_BIT) # Generate trace vertices for each monitor. if self.devices is not None: self._gen_trace() # Draw trace for each monitor. for i, key in enumerate(self.monitors.monitors_dictionary.keys()): # Shade trace in a color corresponding to device type device_id = key[0] if self.devices is not None: color = self.devices.get_device(device_id).device_kind GL.glColor4f(*self.color_dict[color]) GL.glBegin(GL.GL_QUADS) for q in self.quads[i]: x, y = q GL.glVertex2f(x, y) GL.glEnd() GL.glColor3f(0.0, 0.0, 1.0) GL.glLineWidth(GL.GLfloat(3)) # GL_LINES differs from GL_LINE_STRIP, in that # lines are only created between pairs of vertices. GL.glBegin(GL.GL_LINES) for k in self.traces[i]: x, y = k GL.glVertex2f(x, y) GL.glEnd() # We have been drawing to the back buffer, flush the graphics pipeline # and swap the back buffer to the front GL.glFlush() self.SwapBuffers()
def render(self): self.framebufferObject().setAttachment( QOpenGLFramebufferObject.CombinedDepthStencil) e = GL.glGetError() #clear any pending errors c = self.background_color GL.glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF()) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) GL.glBlendEquation(GL.GL_FUNC_ADD) GL.glEnable(GL.GL_PRIMITIVE_RESTART) GL.glPrimitiveRestartIndex(0xFFFFFFFF) GL.glDrawBuffers(len(self.draw_buffers), self.draw_buffers) #opengl_error_check(currentframe()) if self.render_to_texture_attachment != -1: GL.glFramebufferTexture2D( GL.GL_FRAMEBUFFER, self.draw_buffers[self.render_to_texture_attachment], GL.GL_TEXTURE_2D, self.locked_render_to_texture_array.___tex___.textureId(), 0) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) if GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: raise RuntimeError("glCheckFramebufferStatus() problem") #opengl_error_check(currentframe()) for actor in self.bo_actors: try: program = actor['program'] indices = actor['indices'] attribs = actor['attribs'] textures = actor['textures'] out_textures = actor['out_textures'] transform = actor['transform'] uniforms = actor['uniforms'] primitiveType = actor['primitiveType'] point_size = actor['point_size'] line_width = actor['line_width'] program.bind() self.vertex_array.bind() for name, bo in viewitems(attribs): if bo is None: continue bo.bind() loc = program.attributeLocation(name) program.enableAttributeArray(loc) dim = bo.shape[1] if len(bo.shape) > 1 else 1 if bo.dtype == np.float32: program.setAttributeBuffer(loc, GL.GL_FLOAT, 0, dim) elif bo.dtype == np.int32: program.setAttributeBuffer(loc, GL.GL_INT, 0, dim) else: raise ValueError( f'Unsupported dtype {bo.dtype} for attrib {name}') #opengl_error_check(currentframe()) m = transform v = self.view_matrix p = self.perspective_matrix if program.uniformLocation("matrix") == -1: program.setUniformValue("model_matrix", m) program.setUniformValue("view_matrix", v) program.setUniformValue("projection_matrix", p) program.setUniformValue("normal_matrix", m.normalMatrix()) program.setUniformValue("view_matrix_inv", v.inverted()[0]) else: program.setUniformValue("matrix", p * v * m) if program.uniformLocation("ortho_matrix") != -1: program.setUniformValue("ortho_matrix", self.orthographic_matrix) if program.uniformLocation("aspect_ratio") != -1: program.setUniformValue( "aspect_ratio", self.viewport_width / self.viewport_height) #opengl_error_check(currentframe()) if program.uniformLocation("point_size") != -1: GL.glDisable(GL.GL_PROGRAM_POINT_SIZE) program.setUniformValue("point_size", float(point_size)) elif point_size != 1: try: GL.glEnable(GL.GL_PROGRAM_POINT_SIZE) GL.glPointSize(GL.GLfloat(point_size)) except Exception as e: # glPointSize is refused by the driver LoggingManager.instance().warning( f"glPointSize failed with: exception {e}") #opengl_error_check(currentframe()) for name, value in viewitems(uniforms): program.setUniformValue(name, value) #opengl_error_check(currentframe(), f"error with uniform {name}, {value}") texture_unit = 0 for name, tex in viewitems(textures): tex.bind(texture_unit) program.setUniformValue(name, texture_unit) #opengl_error_check(currentframe(), f"error with texture {name}, {value}") texture_unit += 1 for name, tex in viewitems(out_textures): if tex is None: LoggingManager.instance().warning( f'output texture {name} is null') continue # in your fragment shader, you can specify the location via the layout decoration # e.g. layout(location = 1) out vec4 my_output; loc = GL.glGetFragDataLocation(program.programId(), name) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, self.get_texture_attachment(loc), GL.GL_TEXTURE_2D, tex.textureId(), 0) if GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: raise RuntimeError( "glCheckFramebufferStatus() problem") #opengl_error_check(currentframe()) if line_width != 1: try: GL.glEnable(GL.GL_LINE_SMOOTH) #opengl_error_check(currentframe()) GL.glLineWidth(GL.GLfloat(line_width)) except Exception as e: aliased_r = (GL.GLfloat * 2)() GL.glGetFloatv(GL.GL_ALIASED_LINE_WIDTH_RANGE, aliased_r) smooth_r = (GL.GLfloat * 2)() GL.glGetFloatv(GL.GL_SMOOTH_LINE_WIDTH_RANGE, smooth_r) line_r = (GL.GLfloat * 2)() GL.glGetFloatv(GL.GL_LINE_WIDTH_RANGE, line_r) LoggingManager.instance().warning( f"{e}: yout asked for line_width = {line_width}, line range is {list(line_r)}, aliased range is {list(aliased_r)}, smooth range is {list(smooth_r)}" ) else: GL.glDisable(GL.GL_LINE_SMOOTH) #opengl_error_check(currentframe()) if indices is not None and indices.shape[0] > 0: indices.bind() GL.glDrawElements(primitiveType, indices.shape[0], GL.GL_UNSIGNED_INT, None) indices.release() elif attribs["vertices"].shape[0] > 0: GL.glDrawArrays(primitiveType, 0, attribs["vertices"].shape[0]) for name, bo in viewitems(attribs): if bo is not None: bo.release() program.disableAttributeArray(name) for name, tex in viewitems(textures): if tex is not None: tex.release() for name, tex in viewitems(out_textures): if tex is not None: tex.release() for name, tex in viewitems(out_textures): shape = tex.shape tex.bind() loc = GL.glGetFragDataLocation(program.programId(), name) GL.glReadBuffer(self.get_texture_attachment(loc)) if shape[2] == 4: if tex.dtype == np.uint8: pixels = GL.glReadPixels( 0, 0, shape[0], shape[1], GL.GL_RGBA, GL.GL_UNSIGNED_INT_8_8_8_8) self.out_textures[tex] = pixels.view( np.uint8).reshape(shape[1], shape[0], 4) elif tex.dtype == np.float32: pixels = GL.glReadPixels(0, 0, shape[0], shape[1], GL.GL_RGBA, GL.GL_FLOAT) self.out_textures[tex] = pixels tex.release() except Exception as e: LoggingManager.instance().warning(traceback.format_exc()) finally: self.vertex_array.release() program.release() if self.render_to_texture_attachment != -1: shape = self.locked_render_to_texture_array.ndarray.shape self.locked_render_to_texture_array.___tex___.bind() GL.glReadBuffer( self.draw_buffers[self.render_to_texture_attachment]) r = GL.glReadPixels(0, 0, shape[0], shape[1], GL.GL_RGBA, GL.GL_UNSIGNED_INT_8_8_8_8) self.locked_render_to_texture_array.___tex___.release() self.locked_render_to_texture_array.ndarray = np.flipud( r.view(np.uint8).reshape(shape[1], shape[0], 4)[..., ::-1]) self.update()