def v_render(): ''' render to vr and window ''' global hmd, ctx, window # resolve multi-sample offscreen buffer gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO) gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r) gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height, 0, 0, 2 * hmd.width, hmd.height, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST) # blit to window, left only, window is half-size gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, ctx.con.offFBO_r) gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0) gl.glDrawBuffer(gl.GL_BACK if ctx.con.windowDoublebuffer else gl.GL_FRONT) gl.glBlitFramebuffer(0, 0, hmd.width, hmd.height, 0, 0, hmd.width // 2, hmd.height // 2, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST) # blit to vr texture gl.glActiveTexture(gl.GL_TEXTURE2) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, ctx.con.offFBO_r) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1, gl.GL_TEXTURE_2D, hmd.idtex, 0) gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT1) gl.glBlitFramebuffer(0, 0, 2 * hmd.width, hmd.height, 0, 0, 2 * hmd.width, hmd.height, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT1, gl.GL_TEXTURE_2D, 0, 0) gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0) openvr.VRCompositor().submit(openvr.Eye_Left, hmd.vTex, hmd.boundLeft) openvr.VRCompositor().submit(openvr.Eye_Right, hmd.vTex, hmd.boundRight) # swap if window is double-buffered, flush just in case if ctx.con.windowDoublebuffer: glfw.swap_buffers(window) gl.glFlush()
def _create_framebuffer(self): """ Make sure opengl context is bound before calling this method """ fb = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fb) self.texture = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture) GL.glTexImage2D( GL.GL_TEXTURE_2D, # target 0, GL.GL_RGBA, self.fb_size[0], self.fb_size[1], 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None, ) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST) GL.glFramebufferTexture( GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, self.texture, 0 ) GL.glDrawBuffers(1, [GL.GL_COLOR_ATTACHMENT0]) if GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: raise Exception("Incomplete framebuffer") GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) return fb
async def async_main(window, config): await asyncjob.start_worker() imgui_impl = GlfwRenderer(window) renderer = WorldRenderer() app = StarboundMap(renderer) frame_size = np.ones(2) while not glfw.window_should_close(window): glfw.poll_events() if G.minimized: # do not render zero sized frame continue imgui_impl.process_inputs() frame_size = np.array(glfw.get_framebuffer_size(window)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, frame_size[0], frame_size[1]) gl.glClearColor(0.1, 0.1, 0.2, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) app.gui() glfw.swap_buffers(window) await asyncio.sleep(0) config[CONFIG_WIDTH] = str(int(frame_size[0])) config[CONFIG_HEIGHT] = str(int(frame_size[1])) imgui_impl.shutdown() imgui.shutdown()
def __init__(self) -> None: self._fbo = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self._fbo) if GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: print('Framebuffer not complete') GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) self._texture_color = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self._texture_color) 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) self._texture_depth = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self._texture_depth) 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.glBindTexture(GL.GL_TEXTURE_2D, 0)
def renderGL(w, h, func, data): # TODO store original GL context and restore it afterwards? startGL() fbid = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbid) dbid = GL.glGenRenderbuffers(1) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, dbid) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT, w, h) tid = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, tid) 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_RGB, w, h, 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, None) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, tid, 0) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, dbid) assert GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE, 'GL error' GL.glViewport(0, 0, w, h) if isinstance(data, tuple): func(*data) else: func(data) data = GL.glReadPixels(0, 0, w, h, GL.GL_RGB, GL.GL_UNSIGNED_BYTE) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) GL.glDeleteTextures([tid]) GL.glDeleteFramebuffers(1, [fbid]) GL.glDeleteRenderbuffers(1, [dbid]) return np.fromstring(data, dtype=np.uint8).reshape(h, w, 3)
def _init_framebuffer_object(self): """ returns a Framebuffer Object to support offscreen rendering. http://learnopengl.com/#!Advanced-OpenGL/Framebuffers """ fbo = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo) rbo = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rbo) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA, self.init_width, self.init_height) gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, rbo) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) fbo_status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) if fbo_status != gl.GL_FRAMEBUFFER_COMPLETE: gl.glDeleteFramebuffers([fbo]) glfw.terminate() raise Exception('Framebuffer failed status check: %s' % fbo_status) self._fbo = fbo self._rbo = rbo
def captureRGBD(self): ''' XXX DO NOT USE THIS METHOD. Use the capture() instead. This method is called from the GLUT thread. Captures a RGBD frame. ''' try: if self.useFBO: res = [] GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo) for att in self.renderBufferAt: # Read depth from the OpenGL buffer GL.glReadBuffer(att) glBuffer = GL.glReadPixels(0, 0, self.fboWidth, self.fboHeight, GL.GL_RGBA, GL.GL_FLOAT) img = np.flipud(np.array(glBuffer, np.float32).reshape(self.fboHeight,self.fboWidth,4)) res.append(img) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0) return res # no fbo, just return RGBA from default frame buffer. glBuffer = GL.glReadPixels(0, 0, self.width, self.height, GL.GL_RGBA, GL.GL_FLOAT) img = np.flipud(np.array(glBuffer, np.float32).reshape(self.height,self.width,4)) return [img,None,None] except NoContext: print "No OpenGL Context found. If you are calling from a different thread use the capture() method instead." print sys.exc_info()
def initialize(self): if self.handle: self.finalize() self.handle = gl.glGenFramebuffers(1) self.color_attachment_handle = color_attachment_handle = gl.glCreateTextures( gl.GL_TEXTURE_2D, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, color_attachment_handle) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, self.width, self.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, color_attachment_handle, 0) self.depth_attachment_handle = depth_attachment_handle = gl.glCreateTextures( gl.GL_TEXTURE_2D, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, depth_attachment_handle) gl.glTexStorage2D(gl.GL_TEXTURE_2D, 1, gl.GL_DEPTH24_STENCIL8, self.width, self.height) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_STENCIL_ATTACHMENT, gl.GL_TEXTURE_2D, depth_attachment_handle, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def __init__(self, width: int = 128, height: int = 128): self.__fbo = gl.glGenFramebuffers(1) self.__width: int = int(width) self.__height: int = int(height) self.__tex = gl.glGenTextures(1) gl.glActiveTexture(gl.GL_TEXTURE0 + self.__tex) gl.glBindTexture(gl.GL_TEXTURE_2D, self.__tex) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, self.__width, self.__height, 0, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER) gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR, (1.0, 1.0, 1.0, 1.0)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.__fbo) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_TEXTURE_2D, self.__tex, 0) gl.glDrawBuffer(gl.GL_NONE) gl.glReadBuffer(gl.GL_NONE) _checkBoundFramebuffer() gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def __init__(self): self.depthMapFbo = gl.glGenFramebuffers(1) self.shadowW_i = 1024*4 self.shadowH_i = 1024*4 self.program = self._getProgram() self.depthMapTex = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, self.depthMapTex) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, self.shadowW_i, self.shadowH_i, 0, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER) #gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR, (1.0, 1.0, 1.0, 1.0)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.depthMapFbo) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_TEXTURE_2D, self.depthMapTex, 0) gl.glDrawBuffer(gl.GL_NONE) gl.glReadBuffer(gl.GL_NONE) if gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE: print( "ERROR::FRAMEBUFFER:: Framebuffer is not complete!" ) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def renderTranslucent(self): try: GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.translucentFBO) GL.glClearBufferfv(GL.GL_DEPTH, 0, 1) GL_shaders.glUseProgram(self.shaderTranslucent) self.tex1.bind(0) self.model2.bind() GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ModelMatrix'],1, GL.GL_TRUE, self.ModelMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ViewMatrix'],1, GL.GL_TRUE, self.ViewMatrix.get()) GL.glUniformMatrix4fv( self.UNIFORMSTranslucent['my_ProjectionMatrix'],1, GL.GL_TRUE, self.ProjectionMatrix.get()) GL.glUniform1i(self.UNIFORMSTranslucent['tex0'], 0) finally: self.model2.unbind() self.tex1.unbind() GL_shaders.glUseProgram(0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def paintGL(self): # fade out the sparkle plot self.fader.swap_frame_buffer() self.fader.paint_faded(decay=decay_rate) data = np.random.randint(sparkle_width * sparkle_height, size=spikes_per_frame) # generate spike data self.spike_count += len(data) # paint the spikes onto the sparkle plot self.spiker.paint_spikes(data) # switch to rendering on the screen gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, self.width, self.height) # draw the sparkle plot on the screen self.draw_texture.paint(self.fader.get_current_texture()) # print out spike rate now = time.time() if now > self.t_last_msg + 1: dt = now - self.t_last_msg rate = self.spike_count * 0.000001 / dt print 'Mspikes per second = %g' % rate self.spike_count = 0 self.t_last_msg = now
def paintGL(self): GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo) self.paint_quad() GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.defaultFramebufferObject()) GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.paint_to_screen()
def _init_shadow(self): """ Initializes a texture to which we render the depth-map for calculating shadows and creates a framebuffer object that renders the scene's depth component to this texture. """ self.shadow_size = 2048 # configure depth map self.depth_texture_buffer = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.depth_texture_buffer) # create depth texture self.depth_map = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, self.depth_map) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_DEPTH_COMPONENT, self.shadow_size, self.shadow_size, 0, gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_BORDER) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_BORDER) border_color = [1.0, 1.0, 1.0, 1.0] gl.glTexParameterfv(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_BORDER_COLOR, border_color) # attach depth texture as FBO's depth buffer gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_TEXTURE_2D, self.depth_map, 0) gl.glDrawBuffer(gl.GL_NONE) gl.glReadBuffer(gl.GL_NONE) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def draw_to_texture(self, view): gl.glUseProgram(self.program) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo_id) gl.glViewport(0, 0, self.cube_res, self.cube_res) gl.glUniformMatrix4fv(self.view_handle, 1, gl.GL_FALSE, view) # gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, self.texobj_colour_id, 0) # gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, self.texobj_depth_id, 0) for i in range(6): rot_mat = self.eyes_up @ view @ self.matrices[i] gl.glUniformMatrix4fv(self.view_handle, 1, gl.GL_FALSE, rot_mat) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, self.texobj_colour_id, 0) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, self.texobj_depth_id, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glUseProgram(0)
def __init__(self, width, height): # Create the frame buffer. self.fbo_ = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo_) # Create the textures of the frame buffer. self.texture_ = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.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.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_COMPARE_MODE, GL.GL_COMPARE_REF_TO_TEXTURE) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_DEPTH_COMPONENT32F, width, height, 0, GL.GL_DEPTH_COMPONENT, GL.GL_FLOAT, None) GL.glFramebufferTexture(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, self.texture_, 0) GL.glDrawBuffer(GL.GL_NONE) # Check if the frame buffer was created properly. if not GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE: raise RuntimeError("Bind frame buffer failed") GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
def _on_render(self, env): env_info = self._envs[env.id] if self._hidden: glfw.show_window(self._window) self._hidden = False gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glBindTexture(gl.GL_TEXTURE_2D, env_info.texture) # http://stackoverflow.com/questions/27712437/opengl-how-do-i-affect-the-lighting-on-a-textured-plane gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_REPLACE) gl.glEnable(gl.GL_TEXTURE_2D) gl.glBegin(gl.GL_QUADS) gl.glTexCoord2f(0.0, 0.0) gl.glVertex3f(0.0, 0.0, 0) gl.glTexCoord2f(0.0, 1.0) gl.glVertex3f(0.0, 1.0, 0) gl.glTexCoord2f(1.0, 1.0) gl.glVertex3f(1.0, 1.0, 0) gl.glTexCoord2f(1.0, 0.0) gl.glVertex3f(1.0, 0.0, 0) gl.glEnd() gl.glDisable(gl.GL_TEXTURE_2D) # Swap front and back buffers glfw.swap_buffers(self._window)
def draw(self, view, renderer): # gl.glDepthMask(False) gl.glUseProgram(self.program) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, renderer.fbo_id) gl.glViewport(0, 0, renderer.cube_res, renderer.cube_res) # Select skybox VAO gl.glBindVertexArray(self.vao_id) rot_mat = self.eyes_up @ view gl.glUniformMatrix4fv(self.skybox_view_handle, 1, gl.GL_FALSE, rot_mat) # # Bind to the active texture # gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, renderer.texobj_colour_id) # # gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, renderer.texobj_colour_id, 0) # gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, renderer.texobj_depth_id, 0) gl.glDrawArrays(gl.GL_TRIANGLES, 0, self.vao_len) # Release VAO, FBO and program gl.glBindVertexArray(0) gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glUseProgram(0)
def bind_frame_buffer(self, width, height): frame_buffer_name = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, frame_buffer_name) fbo_texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, fbo_texture) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) depth_render_buffer = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, depth_render_buffer) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT, width, height) gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_RENDERBUFFER, depth_render_buffer) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, fbo_texture, 0) drawbuffers = [gl.GL_COLOR_ATTACHMENT0] gl.glDrawBuffers(1, drawbuffers) if gl.glCheckFramebufferStatus( gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE: return False return True
def _on_start_env(self, env): # create framebuffer object to render into fbo = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo) # create texture texture = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, get_config().window_px_width, get_config().window_px_height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) # bind texture to FBO gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, texture, 0) # Check FBO status if gl.glCheckFramebufferStatus( gl.GL_FRAMEBUFFER) != gl.GL_FRAMEBUFFER_COMPLETE: raise "FBO error" # Bind default FBO gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) env_info = EnvInfo(env, fbo=fbo, texture=texture) self._envs[env.id] = env_info
def release(self, stack=True): """ Bind FBO popping it from the stack :param stack: (bool) If the bind should be popped form the FBO stack. """ GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) if not stack: return # Are we trying to release an FBO that is not bound? if not FBO.stack: raise FBOError("FBO stack is already empty. You are probably releasing a FBO twice or forgot to bind.") fbo_out = FBO.stack.pop() # Make sure we released this FBO and not some other random one if fbo_out != self: raise FBOError("Incorrect FBO release order") # Find the parent fbo if FBO.stack: parent = FBO.stack[-1] else: parent = WINDOW_FBO # Bind the parent FBO if parent: parent.bind()
def __init__(self, width, height): self.render_framebuffer_id = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.render_framebuffer_id) # self.depth_buffer_id = GL.glGenRenderbuffers(1) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.depth_buffer_id) GL.glRenderbufferStorageMultisample(GL.GL_RENDERBUFFER, 4, GL.GL_DEPTH_COMPONENT, width, height) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, self.depth_buffer_id) # self.render_texture_id = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D_MULTISAMPLE, self.render_texture_id) GL.glTexImage2DMultisample(GL.GL_TEXTURE_2D_MULTISAMPLE, 4, GL.GL_RGBA8, width, height, True) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D_MULTISAMPLE, self.render_texture_id, 0) # self.resolve_framebuffer_id = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.resolve_framebuffer_id) # self.resolve_texture_id = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.resolve_texture_id) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 0) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA8, width, height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, self.resolve_texture_id, 0) status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) assert status == GL.GL_FRAMEBUFFER_COMPLETE
def __del__(self): GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) if hasattr(self, "FBORENDER"): GL.glDeleteTextures(self.TARGET) GL.glDeleteRenderbuffers(6, self.DEPTH) GL.glDeleteFramebuffers(1, [self.FBORENDER]) report_GL_error() if hasattr(self, "FBOACCUM"): GL.glDeleteTextures([self.ACCUM]) GL.glDeleteTextures([self.AREA]) GL.glDeleteFramebuffers(1, [self.FBOACCUM]) del self.prog report_GL_error() if hasattr(self, "SANGLE"): GL.glDeleteTextures([self.SANGLE]) report_GL_error() if self.mesh is not None: del self.mesh report_GL_error() if hasattr(self, "wnd"): glfw.destroy_window(self.wnd) glfw.terminate()
def setup_fbo(self): self.ctx.makeCurrent(self.offscreen_surface) self.tex = GL.glGenTextures(1) self.fbo = GL.glGenFramebuffers(1) self.rbuf = GL.glGenRenderbuffers(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.tex) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, OffscreenModelRendererThread.TEX_SIZE, OffscreenModelRendererThread.TEX_SIZE, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, None) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.rbuf) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT24, OffscreenModelRendererThread.TEX_SIZE, OffscreenModelRendererThread.TEX_SIZE) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, self.rbuf) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, self.tex, 0) if GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) != GL.GL_FRAMEBUFFER_COMPLETE: raise RuntimeError("Framebuffer is not complete!") GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
def render(self, gltf, nodes, window_size=(800, 600)): self.vr_compositor.waitGetPoses(self.poses, openvr.k_unMaxTrackedDeviceCount, None, 0) hmd_pose = self.poses[openvr.k_unTrackedDeviceIndex_Hmd] if not hmd_pose.bPoseIsValid: return hmd_34 = np.ctypeslib.as_array(cast(hmd_pose.mDeviceToAbsoluteTracking.m, c_float_p), shape=(3,4)) self.view[:3,:] = hmd_34 view = np.linalg.inv(self.view.T) view.dot(self.eye_transforms[0], out=self.view_matrices[0]) view.dot(self.eye_transforms[1], out=self.view_matrices[1]) gl.glViewport(0, 0, self.vr_framebuffers[0].width, self.vr_framebuffers[0].height) for eye in (0, 1): gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.vr_framebuffers[eye].fb) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gltfu.set_material_state.current_material = None gltfu.set_technique_state.current_technique = None for node in nodes: gltfu.draw_node(node, gltf, projection_matrix=self.projection_matrices[eye], view_matrix=self.view_matrices[eye]) self.controllers.display_gl(self.view_matrices[eye], self.projection_matrices[eye]) self.vr_compositor.submit(openvr.Eye_Left, self.vr_framebuffers[0].texture) self.vr_compositor.submit(openvr.Eye_Right, self.vr_framebuffers[1].texture) # mirror left eye framebuffer to screen: gl.glBlitNamedFramebuffer(self.vr_framebuffers[0].fb, 0, 0, 0, self.vr_framebuffers[0].width, self.vr_framebuffers[0].height, 0, 0, window_size[0], window_size[1], gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def _init_framebuffer_object(self): """ returns a Framebuffer Object to support offscreen rendering. http://learnopengl.com/#!Advanced-OpenGL/Framebuffers """ fbo = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo) rbo = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rbo) gl.glRenderbufferStorage( gl.GL_RENDERBUFFER, gl.GL_RGBA, self.init_width, self.init_height ) gl.glFramebufferRenderbuffer( gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, rbo) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) fbo_status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) if fbo_status != gl.GL_FRAMEBUFFER_COMPLETE: gl.glDeleteFramebuffers([fbo]) glfw.terminate() raise Exception('Framebuffer failed status check: %s' % fbo_status) self._fbo = fbo self._rbo = rbo
def draw(self, view, renderer): gl.glUseProgram(renderer.program) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, renderer.fbo_id) gl.glViewport(0, 0, renderer.cube_res, renderer.cube_res) gl.glUniformMatrix4fv(renderer.view_handle, 1, gl.GL_FALSE, view) # Select mesh VAO gl.glBindVertexArray(self.vao_id) # Bind to the active texture gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, renderer.texobj_colour_id) gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, renderer.texobj_colour_id, 0) gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, renderer.texobj_depth_id, 0) gl.glDrawElements( gl.GL_TRIANGLES, # Mode self.nb_faces * 3, # Count gl.GL_UNSIGNED_INT, # Type ctypes.c_void_p(0)) # Element array buffer offset (None) # Release VAO, FBO and program gl.glBindVertexArray(0) gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glUseProgram(0)
def __init__(self, window_width, window_height): self._framebuf = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self._framebuf) self._picktex = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self._picktex) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, window_width, window_height, 0, GL.GL_RGB, GL.GL_FLOAT, None) GL.glFramebufferTexture2D(GL.GL_DRAW_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, self._picktex, 0) self._depthtex = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self._depthtex) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_DEPTH_COMPONENT, window_width, window_height, 0, GL.GL_DEPTH_COMPONENT, GL.GL_FLOAT, None) GL.glFramebufferTexture2D(GL.GL_DRAW_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_TEXTURE_2D, self._depthtex, 0) GL.glReadBuffer(GL.GL_NONE) GL.glDrawBuffer(GL.GL_COLOR_ATTACHMENT0) # Restore the default framebuffer GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def __init__(self, bufferFormats, width, height): if len(bufferFormats) > 6: raise RuntimeError("Number of attachement to buffer too high: " + str(len(bufferFormats))) # Create the frame buffer. self.textures_ = [] self.fbo_ = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo_) self.colorAttList_ = [ GL.GL_COLOR_ATTACHMENT0, GL.GL_COLOR_ATTACHMENT1, GL.GL_COLOR_ATTACHMENT2, GL.GL_COLOR_ATTACHMENT3, GL.GL_COLOR_ATTACHMENT4, GL.GL_COLOR_ATTACHMENT5, GL.GL_COLOR_ATTACHMENT6 ] self.formatDict_ = { GL.GL_RGBA32F: (GL.GL_RGBA, GL.GL_FLOAT), GL.GL_RGBA: (GL.GL_RGBA, GL.GL_UNSIGNED_BYTE), GL.GL_R32I: (GL.GL_RED_INTEGER, GL.GL_INT), GL.GL_RGBA32I: (GL.GL_RGBA_INTEGER, GL.GL_INT) } # Create the textures of the frame buffer. for it, currFormat in enumerate(bufferFormats): if not (currFormat in self.formatDict_): raise RuntimeError( "The texture format is not in the dictionary: " + str(currFormat)) myFormat = self.formatDict_[currFormat] texture = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, texture) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST) GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, currFormat, width, height, 0, myFormat[0], myFormat[1], None) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, self.colorAttList_[it], GL.GL_TEXTURE_2D, texture, 0) self.textures_.append(texture) # Creaet the render buffer. self.rbo_ = GL.glGenRenderbuffers(1) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, self.rbo_) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH24_STENCIL8, width, height) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_STENCIL_ATTACHMENT, GL.GL_RENDERBUFFER, self.rbo_) # Check if the frame buffer was created properly. if not GL.glCheckFramebufferStatus( GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE: raise RuntimeError("Bind frame buffer failed") GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, 0)
def startRenderOn(self, lightProjection, lightView): gl.glDisable(gl.GL_CULL_FACE) gl.glUseProgram(self.__program) gl.glViewport(0, 0, self.__shadowW_i, self.__shadowH_i) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.__depthMapFbo) gl.glClear(gl.GL_DEPTH_BUFFER_BIT) gl.glUniformMatrix4fv(1, 1, gl.GL_FALSE, lightView * lightProjection)
def _configure_screen_frame_buffer(texture_object): frame_buffer_object = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, frame_buffer_object) GL.glFramebufferTexture(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, texture_object, 0) GL.glDrawBuffers(1, [GL.GL_COLOR_ATTACHMENT0]) assert GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) == GL.GL_FRAMEBUFFER_COMPLETE GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) return frame_buffer_object
def read(self, x, y): GL.glBindFramebuffer(GL.GL_READ_FRAMEBUFFER, self._framebuf) with self.enable(): GL.glReadBuffer(GL.GL_COLOR_ATTACHMENT0) pixel = GL.glReadPixels(x, y, 1, 1, GL.GL_RGB, GL.GL_FLOAT) GL.glReadBuffer(GL.GL_NONE) return pixel[0][0]
def render(self, scene, camera, light=(1.0, 1.0, 1.0)): # tr = tracker.SummaryTracker() self.ctx.clear() # create a C-style binary buffer for the scene data scene_packed = scene.pack() vbo = self.ctx.buffer(scene_packed) # merge the textures and load them into a buffer scene.pack_textures() # load the scene data (vertices, colors, etc.) into the renderer vao = self.ctx.simple_vertex_array(self.prog, vbo, *self.shader["params"]) # get the camera parameters and feed them into the renderer proj, lookat = camera.get_view_model() self.prog['model'].write((proj * lookat).astype('f4').tobytes()) self.prog['Light'].value = light # prog['Color'].value = (1.0, 1.0, 1.0, 0.25) # render out the current vao.render(moderngl.TRIANGLES) if self.msaa > 0: gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, self.fbo_msaa.glo) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, self.fbo.glo) gl.glBlitFramebuffer(0, 0, self.size[0], self.size[1], 0, 0, self.size[0], self.size[1], gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT, gl.GL_NEAREST) # gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, self.fbo_msaa.glo) # gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, self.fbo.glo) # gl.glBlitFramebuffer(0, 0, self.size[0], self.size[1], 0, 0, # self.size[0], self.size[1], # , gl.GL_LINEAR) # get the RGB data and convert to numpy array raw = self.fbo.read(components=4, dtype='f4') # RGBA, floats img = np.frombuffer( raw, dtype='f4').reshape((camera.height, camera.width, 4)) # the y axis is flipped during rendering, so we have to unflip this. # and the image has 4 channels: RGB+Alpha, but we don't care about alpha. # note that the image will be numpy.float32 in range [0,1] img = img[::-1, :, :3] # get the depth buffer and conver to numpy depth = np.frombuffer( self.dbo_smol.read(alignment=1), dtype=np.dtype('f4')).reshape(camera.size()) # similar to the RGB, the dept is flipped upside-down as well so we need to unflip. depth = depth[::-1, :] # tr.print_diff() return img, depth
def draw(self): GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.framebuffer) self.shader_program.bind() GL.glBindVertexArray(self.vertex_attribute_object) GL.glActiveTexture(GL.GL_TEXTURE0) GL.glBindTexture(GL.GL_TEXTURE_2D, self.texture) GL.glDrawArrays(GL.GL_TRIANGLES, 0, 6) GL.glBindVertexArray(0) self.shader_program.release()
def setup_fb(self, width, height): '''Sets up FrameBuffer that will be used as container for 1 pass of rendering''' # Clean up old FB and Texture if self.fb_texture is not None and \ GL.glIsTexture(self.fb_texture): GL.glDeleteTextures([self.fb_texture]) if self.fbo is not None and GL.glIsFramebuffer(self.fbo): GL.glDeleteFramebuffers(1, [self.fbo]) # initialize FrameBuffer self.fbo = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo) depthbuffer = GL.glGenRenderbuffers(1) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER, depthbuffer) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER, GL.GL_DEPTH_COMPONENT32F, width, height) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, GL.GL_RENDERBUFFER, depthbuffer) # end of FrameBuffer initialization # generate the texture we render to, and set parameters self.fb_texture = GL.glGenTextures(1) # create target texture # bind to new texture, all future texture functions will modify this # particular one GL.glBindTexture(GL.GL_TEXTURE_2D, self.fb_texture) # set how our texture behaves on x,y boundaries GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT) GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT) # set how our texture is filtered 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) # occupy width x height texture memory, (None at the end == empty # image) GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA32F, width, height, 0, GL.GL_RGBA, GL.GL_FLOAT, None) # --- end texture init # Set "fb_texture" as our colour attachement #0 GL.glFramebufferTexture2D( GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, self.fb_texture, 0 # mipmap level, normally 0 ) # verify that everything went well status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) assert status == GL.GL_FRAMEBUFFER_COMPLETE, status
def mySetup(self): # Create two shaders: self.shader_1 = self.loadShader("vs_1.glsl", "fs_1.glsl") self.UNIFORMS_1 = { 'tex0':GL.glGetUniformLocation(self.shader_1, 'tex0')} self.shader_2 = self.loadShader("vs_2.glsl", "fs_2.glsl") self.UNIFORMS_2 = { 'col_tex':GL.glGetUniformLocation(self.shader_2, 'col_tex')} #Define geometry: self.vbo = GL_vbo.VBO( np.array([ [-1.0,-1.0, 0.0, 0.0, 0.0], [ 1.0,-1.0, 0.0, 1.0, 0.0], [ 1.0, 1.0, 0.0, 1.0, 1.0], [-1.0, 1.0, 0.0, 0.0, 1.0], ], dtype=np.float32), target=GL.GL_ARRAY_BUFFER) self.ibo = GL_vbo.VBO( np.array([ [0, 1, 3], [1, 2, 3] ], dtype=np.uint32), target=GL.GL_ELEMENT_ARRAY_BUFFER) file = PIL_Image.open("tex0.png") file = file.convert('RGBA') file_stream = file.tostring('raw', 'RGBA', 0, -1) # Assign an ID to this texture: self.tex0_ID = 0; ID = GL.glGenTextures(1) GL.glActiveTexture(GL.GL_TEXTURE0 + self.tex0_ID) GL.glBindTexture(GL.GL_TEXTURE_2D, ID) 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_s3tc.GL_COMPRESSED_RGB_S3TC_DXT1_EXT, file.size[0], file.size[1], 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, file_stream) del file, file_stream self.fbo = GL.glGenFramebuffers(1) ## Look into ctypes and pointers! GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.fbo) self.col_tex_ID = 1 self.col_tex = GL.glGenTextures(1) GL.glActiveTexture(GL.GL_TEXTURE0 + self.col_tex_ID) GL.glBindTexture(GL.GL_TEXTURE_2D, self.col_tex) GL.glTexStorage2D(GL.GL_TEXTURE_2D, 1, GL.GL_DEPTH_COMPONENT32F, 512, 512) # "GL.GL_DEPTH_COMPONENT32F" for depth testing # "GL.GL_RGBA8" for color testing GL.glFramebufferTexture( GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, self.col_tex, 0)
def doShader(self, program, sources, uniform2f=[], uniform1f=[], uniform2i=[], uniform1i=[], render_target=None, position=(0,0), size=(100,100), readback=False): if render_target == None: #resize the screen if necessary if position[0] + size[0] > self.width: self.resizefunc(50,50,position[0]+size[0],self.height+1) if position[1] + size[1] > self.height: self.resizefunc(50,50,self.width,position[1]+size[1]+1) #do opengl stuff gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(position[0],position[1],size[0],size[1]) else: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, render_target.fb) gl.glViewport(0,0,render_target.width,render_target.height) #tell OpenGL which shader program to use for this render gl.glUseProgram(program.program) #set any uniform variables we got as arguments for x in uniform1i: #tuple ("name", value) gl.glUniform1i(gl.glGetUniformLocation(program.program, x[0]),x[1]) for x in uniform2i: #tuple ("name", value1, value2) gl.glUniform2i(gl.glGetUniformLocation(program.program, x[0]),x[1],x[2]) for x in uniform1f: #tuple ("name", value) gl.glUniform1f(gl.glGetUniformLocation(program.program, x[0]),x[1]) for x in uniform2f: #tuple ("name", value1, value2) gl.glUniform2f(gl.glGetUniformLocation(program.program, x[0]),x[1],x[2]) #bind vertex buffer self.vbo.bind() #bind textures texunits = [gl.GL_TEXTURE0, gl.GL_TEXTURE1, gl.GL_TEXTURE2, gl.GL_TEXTURE3] for (i,x) in enumerate(sources): gl.glActiveTexture(texunits[i]) if not program.ferror: gl.glBindTexture(gl.GL_TEXTURE_2D, x.tex) else: gl.glBindTexture(gl.GL_TEXTURE_2D, error_image.tex) gl.glActiveTexture(texunits[0]) #do the actual drawing loc = gl.glGetAttribLocation(self.input_program.program, "vertex") gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, gl.GL_FALSE, 16, None) gl.glEnableVertexAttribArray(loc) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) #readback if readback: if render_target == None: # Capture image from the OpenGL buffer buffer = ( gl.GLubyte * (4*size[0]*size[1]) )(0) gl.glReadPixels(0, 0, size[0], size[1], gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, buffer) return buffer else: # Capture image from the OpenGL buffer buffer = ( gl.GLubyte * (4*render_target.width*render_target.height) )(0) gl.glReadPixels(0, 0, render_target.width, render_target.height, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, buffer) return buffer return
def display(): gl.glStencilMask(255) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT | gl.GL_STENCIL_BUFFER_BIT) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, fbo) shadowProgram.draw(gl.GL_TRIANGLES, indices) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) # Filled cube # gl.glDisable(gl.GL_BLEND) # gl.glEnable(gl.GL_DEPTH_TEST) # gl.glEnable(gl.GL_POLYGON_OFFSET_FILL) program['u_color'] = 1,1,1,1 program['u_scale'] = 1,1,1 program['draw_shadow'] = 1 program.draw(gl.GL_TRIANGLES, indices) gl.glEnable(gl.GL_STENCIL_TEST) gl.glStencilFunc(gl.GL_ALWAYS, 1, 255) gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_REPLACE) # gl.glStencilFunc(gl.GL_NEVER, 1, 255) # gl.glStencilOp(gl.GL_REPLACE, gl.GL_REPLACE, gl.GL_REPLACE) gl.glStencilMask(255) gl.glDepthMask(gl.GL_FALSE) program2['u_color'] = 1,1,1,1 program2['u_scale'] = 1,1,1 program2.draw(gl.GL_TRIANGLE_STRIP) gl.glStencilFunc(gl.GL_EQUAL, 1, 255); #gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_REPLACE) gl.glStencilMask(0) gl.glDepthMask(gl.GL_TRUE) model = np.eye(4, dtype=np.float32) translate(model, 0, -2, 0) rotate(model, phi, 0,1,0) program['model'] = model program['u_color'] = 0.5, 0.5, 0.5, 1 program['u_scale'] = 1,-1,1 program['draw_shadow'] = 0 program.draw(gl.GL_TRIANGLES, indices) gl.glDisable(gl.GL_STENCIL_TEST) # Outlined cube # gl.glDisable(gl.GL_POLYGON_OFFSET_FILL) # gl.glEnable(gl.GL_BLEND) # gl.glDepthMask(gl.GL_FALSE) # program['u_color'] = 0,0,0,1 # program.draw(gl.GL_LINES, outline) # gl.glDepthMask(gl.GL_TRUE) glut.glutSwapBuffers()
def paintGL(self): now = time.time() if self.last_time is None: decay = 0.0 self.dt = None else: dt = now - self.last_time if self.dt is None: self.dt = dt else: #self.dt = dt self.dt = (0.9) * self.dt + (0.1) * dt self.last_time = now if self.dt is not None: self.slider.swap_frame_buffer(int(self.dt/0.001)) self.slider.paint_slid() #data = self.data data = np.random.randint(raster_n_neurons, size=spikes_per_frame).astype('int32') # generate spike data self.spike_count += len(data) # paint the spikes onto the sparkle plot self.slider.swap_frame_buffer(0, False) self.raster.paint_spikes(data) # switch to rendering on the screen gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, self.width, self.height) # draw the sparkle plot on the screen self.draw_texture.paint(self.slider.get_current_texture()) # print out spike rate now = time.time() if now > self.t_last_msg + 1: dt = now - self.t_last_msg rate = self.spike_count * 0.000001 / dt print 'Mspikes per second = %g' % rate self.spike_count = 0 self.t_last_msg = now # flag a redraw self.update()
def swap_frame_buffer(self, slide=1, swap=True): """Switch buffers so we alternate which one we're rendering to.""" if swap: self.usingA = not self.usingA if self.usingA: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureA, 0); else: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureB, 0); # reset the geometry so we render to the whole image gl.glViewport(-slide, 0, self.width, self.height)
def setupOpaque(self): self.opaqueFBO = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, self.opaqueFBO) self.opaqueDEPTHtex = GL.glGenTextures(1) GL.glBindTexture(GL.GL_TEXTURE_2D, self.opaqueDEPTHtex) GL.glTexStorage2D( GL.GL_TEXTURE_2D, 1, GL.GL_DEPTH_COMPONENT32F, self.screen_size[0], self.screen_size[1]) GL.glFramebufferTexture( GL.GL_FRAMEBUFFER, GL.GL_DEPTH_ATTACHMENT, self.opaqueDEPTHtex, 0) GL.glBindTexture(GL.GL_TEXTURE_2D, 0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0)
def paint(self): # fade out the sparkle plot self.fader.swap_frame_buffer() self.fader.paint_faded(decay=self.decay_rate) spikes_per_frame = 100 data = np.random.randint(self.grid_width * self.grid_height, size=spikes_per_frame) # paint the spikes onto the sparkle plot self.spiker.paint_spikes(data) # switch to rendering on the screen gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, self.width, self.height) # draw the sparkle plot on the screen self.draw_texture.paint(self.fader.get_current_texture())
def initializeGL(self): """Initialize OpenGL, VBOs, upload data on the GPU, etc.""" # background color gl.glClearColor(0, 0, 0, 0) vs = glhelpers.compile_vertex_shader(VS) fs = glhelpers.compile_fragment_shader(FS) self.shaders_program = glhelpers.link_shader_program(vs, fs) vs_texture = glhelpers.compile_vertex_shader(VS_texture) fs_texture = glhelpers.compile_fragment_shader(FS_texture) self.shaders_program_texture = glhelpers.link_shader_program(vs_texture, fs_texture) # create the texture self.texture = gl.glGenTextures(1, ['sparkle']) gl.glBindTexture(gl.GL_TEXTURE_2D, self.texture) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) data = np.tile([255,0,255,0],(256, 256)).flatten() gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, 256, 256, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, data) self.fb = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fb); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.texture, 0); gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer self.square = glvbo.VBO( np.array( [ [ -2,-2, 0 ], [ 2,-2, 0 ], [ 2, 2, 0 ], [ -2,-2, 0 ], [ 2, 2, 0 ], [ -2, 2, 0 ], ],'f') * 0.25 )
def toTexture(self, width=None, height=None): if width is None: width = self.width if height is None: height = self.height self.tex = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, self.tex) if self.empty: #create empty texture gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) else: #use data buffer gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, self.data) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glBindTexture(gl.GL_TEXTURE_2D, 0) #generate a frame-buffer as well self.fb = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER,self.fb) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER,gl.GL_COLOR_ATTACHMENT0,gl.GL_TEXTURE_2D,self.tex,0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER,0)
def with_opengl_texture(cls, debug = SETTINGS['debug'], ): # see http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/ # The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer. FramebufferName = gl.GLuint(0) gl.glGenFramebuffers(1, ctypes.byref(FramebufferName)) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, FramebufferName) # The texture we're going to render to renderedTexture = gl.GLuint(0) gl.glGenTextures(1, ctypes.byref(renderedTexture)) # "Bind" the newly created texture : all future texture functions will modify this texture gl.glBindTexture(gl.GL_TEXTURE_2D, renderedTexture) # Give an empty image to OpenGL ( the last "0" ) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, 1024, 768, 0,gl.GL_RGB, gl.GL_UNSIGNED_BYTE, 0) # Poor filtering. Needed ! gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) # Set "renderedTexture" as our colour attachement #0 gl.glFramebufferTexture(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, renderedTexture, 0); # Set the list of draw buffers. DrawBuffers = gl.GLenum * 1 #gl.GLenum DrawBuffers[1] DrawBuffers[0] = gl.GL_COLOR_ATTACHMENT0 # = {gl.GL_COLOR_ATTACHMENT0}; gl.glDrawBuffers(1, DrawBuffers); # "1" is the size of DrawBuffers return cls(width = w, height = h, constrain_aspect = constrain_aspect, display_surface = surf, run_mode = 'open_gltexture', )
def _initFBO(self): self.fboWidth = self.width self.fboHeight = self.height # Create three Render buffers. One for color one for XYZW one for depth_component self.renderBuffers = GL.glGenRenderbuffers(3) # initialize storage for the render buffers for i in range(2): GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,self.renderBuffers[i]) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER,GL.GL_RGBA32F,self.fboWidth,self.fboHeight) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,0) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,self.renderBuffers[2]) GL.glRenderbufferStorage(GL.GL_RENDERBUFFER,GL.GL_DEPTH_COMPONENT,self.fboWidth,self.fboHeight) GL.glBindRenderbuffer(GL.GL_RENDERBUFFER,0) self.fbo = GL.glGenFramebuffers(1) # bind buffer and populate with RenderBuffers GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo) self.renderBufferAt = [GL.GL_COLOR_ATTACHMENT0,GL.GL_COLOR_ATTACHMENT1] GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,self.renderBufferAt[0],GL.GL_RENDERBUFFER,self.renderBuffers[0]) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,self.renderBufferAt[1],GL.GL_RENDERBUFFER,self.renderBuffers[1]) GL.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,GL.GL_DEPTH_ATTACHMENT,GL.GL_RENDERBUFFER,self.renderBuffers[2]) # make sure that the new FBO is complete status = GL.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER) if status != GL.GL_FRAMEBUFFER_COMPLETE: raise StandardError("Failed to properly setup FBO. OpenGL returned FBO status: ",status) #unbind FBO GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0) print "FBO initialized correctly."
def _init_render(self): """ Initialize framebuffers to render offscreen, i.e. without displaying a window """ # Framebuffer self.fbo = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo) # Color renderbuffer self.rbo_color = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.rbo_color) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA8, self.width, self.height) gl.glFramebufferRenderbuffer(gl.GL_DRAW_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, self.rbo_color) # Depth and stencil renderbuffer. self.rbo_depth_stencil = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, self.rbo_depth_stencil) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH24_STENCIL8, self.width, self.height) gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_STENCIL_ATTACHMENT, gl.GL_RENDERBUFFER, self.rbo_depth_stencil) gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbo) # Sanity check assert fbos.glCheckFramebufferStatusEXT(gl.GL_FRAMEBUFFER) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
def paintGL(self): now = time.time() if self.last_time is None: decay = 1.0 else: decay = np.exp((self.last_time - now) / self.decay_time) decay = 0.9 self.last_time = now # fade out the sparkle plot self.fader.swap_frame_buffer() self.fader.paint_faded(decay=decay) while len(self.data) > 0: data = self.data.pop() self.spike_count += len(data) # paint the spikes onto the sparkle plot self.spiker.paint_spikes(data, scale=1) # switch to rendering on the screen gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, self.width, self.height) # draw the sparkle plot on the screen self.draw_texture.paint(self.fader.get_current_texture()) # print out spike rate if now > self.t_last_msg + 1: dt = now - self.t_last_msg rate = self.spike_count * 0.000001 / dt print 'Mspikes per second = %g' % rate self.spike_count = 0 self.t_last_msg = now # flag a redraw self.update()
def render_to_texture(texture): fbo = GL.glGenFramebuffers(1) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbo) GL.glFramebufferTexture2D(GL.GL_FRAMEBUFFER, GL.GL_COLOR_ATTACHMENT0, GL.GL_TEXTURE_2D, texture, 0) GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, fbo) yield GL.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0) GL.glDeleteFramebuffers(1, numpy.array(fbo))
def unbind(self): if len(RenderTarget.id_stack): del RenderTarget.id_stack[-1] if len(RenderTarget.id_stack) >= 1: id = RenderTarget.id_stack[-1] gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, id) else: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
def on_draw(self): if self.started is False: return view = self.controller.getViewM() self.shader.uniform_matrixf("viewM", view) red,green,blue,alpha = 1,1,1,1 GL.glClearColor(red,green,blue,alpha) if self.useFBO is True: GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,self.fbo) GL.glDrawBuffers(2,self.renderBufferAt) self._draw() # Draw on the FBO GL.glBindFramebuffer(GL.GL_FRAMEBUFFER,0) GL.glBindFramebuffer(GL.GL_READ_FRAMEBUFFER, self.fbo); GL.glReadBuffer(GL.GL_COLOR_ATTACHMENT0); # read from FBO color0 GL.glBindFramebuffer(GL.GL_DRAW_FRAMEBUFFER, 0); GL.glDrawBuffers((GL.GL_BACK,)) # write to window frame buffer color0 GL.glBlitFramebuffer(0,0,self.fboWidth,self.fboHeight,0,0,self.width,self.height,GL.GL_COLOR_BUFFER_BIT,GL.GL_LINEAR) else: self._draw()
def render(): global image # Draw to the offscreen FBO gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fbo) gl.glDrawBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glDrawArrays(gl.GL_TRIANGLE_STRIP, 0, 4) # Start to copy off to the pixel buffer; this will continue # asynchronously with frame delay gl.glBindBuffer(gl.GL_PIXEL_PACK_BUFFER, pb) # Yes, you have to do glBufferData every time gl.glBufferData(gl.GL_PIXEL_PACK_BUFFER, WINDOW_WIDTH * WINDOW_HEIGHT * 4, ctypes.c_void_p(0), gl.GL_DYNAMIC_READ) gl.glReadPixels(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, ctypes.c_void_p(0)) # Copy from offscreen framebuffer to display framebuffer gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, fbo) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, 0) gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT0) gl.glDrawBuffer(gl.GL_BACK_LEFT) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glBlitFramebuffer(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, gl.GL_COLOR_BUFFER_BIT, gl.GL_NEAREST) # Now actually map to the pixel buffer and copy image data image_data_p = ctypes.c_void_p(gl.glMapBuffer(gl.GL_PIXEL_PACK_BUFFER, gl.GL_READ_ONLY)) image_data_ubyte_p = ctypes.cast(image_data_p, ctypes.POINTER(ctypes.c_ubyte)) image = np.ctypeslib.as_array(image_data_ubyte_p, shape=(WINDOW_WIDTH, WINDOW_HEIGHT, 4)) gl.glUnmapBuffer(gl.GL_PIXEL_PACK_BUFFER)
def gl_get_configuration(): """ Read gl configuration independently of backends. """ import ctypes import OpenGL.GL as gl configuration = Configuration() gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) value = ctypes.c_int() try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT, gl.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, value ) configuration._red_size = value.value except: log.warn("Cannot read RED channel size from the framebuffer") configuration._red_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT, gl.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, value ) configuration._green_size = value.value except: log.warn("Cannot read GREEN channel size from the framebuffer") configuration._green_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT, gl.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, value ) configuration._blue_size = value.value except: log.warn("Cannot read BLUE channel size from the framebuffer") configuration._blue_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT, gl.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, value ) configuration._alpha_size = value.value except: log.warn("Cannot read ALPHA channel size from the framebuffer") configuration._alpha_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_DEPTH, gl.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, value ) configuration._depth_size = value.value except: log.warn("Cannot read DEPTH size from the framebuffer") configuration._depth_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_STENCIL, gl.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, value ) configuration._stencil_size = value.value except: log.warn("Cannot read STENCIL size from the framebuffer") configuration._stencil_size = 0 try: gl.glGetFramebufferAttachmentParameteriv( gl.GL_FRAMEBUFFER, gl.GL_FRONT_LEFT, gl.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, value ) if value.value == gl.GL_LINEAR: configuration._srgb = False elif value.value == gl.GL_SRGB: configuration._srgb = True except: log.warn("Cannot read sRGB value from the framebuffer") configuration._srgb = False configuration._stereo = gl.glGetInteger(gl.GL_STEREO) configuration._double_buffer = gl.glGetInteger(gl.GL_DOUBLEBUFFER) configuration._samples = gl.glGetInteger(gl.GL_SAMPLES) # Dumb parsing of the GL_VERSION string version = gl.glGetString(gl.GL_VERSION) version = version.split(" ")[0] major,minor = version.split('.')[:2] configuration._version = version configuration._major_version = int(major) configuration._minor_version = int(minor) configuration._profile = "unknown" return configuration
def unbind(self): gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
createBufferTexture(textureID[1], texw, texh) createBufferTexture(textureID[2], texw, texh) fboID = gl.glGenFramebuffers(1) programObj0 = createShader("vertex.glsl", "fragment_seed.glsl") programObj1 = createShader("vertex.glsl", "fragment_flood.glsl") programObj2 = createShader("vertex.glsl", "fragment_display.glsl") glfw.glfwSwapInterval(0) running = True while running: showFPS(texw, texh) if not useShaders: gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[0]) # Pass-through else: setUniformVariables(programObj0, 0, texw, texh, 0) gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[0]) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fboID) lastRendered = 1 gl.glFramebufferTexture2D(gl.GL_DRAW_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, textureID[lastRendered], 0) renderScene(programObj0, texw, texh) stepsize = texw//2 if texw > texh else texh//2 while stepsize > 0: setUniformVariables(programObj1, 0, texw, texh, stepsize) gl.glBindTexture(gl.GL_TEXTURE_2D, textureID[lastRendered]) lastRendered = 1 if lastRendered == 2 else 2 gl.glFramebufferTexture2D(gl.GL_DRAW_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, textureID[lastRendered], 0)
def gl_init_routine(): global program global fbo global rb global pb global image # Compile and link shaders vert_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) frag_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) with open('surface_vert.glsl') as f: vert_shader_text = f.read() with open('surface_frag.glsl') as f: frag_shader_text = f.read() gl.glShaderSource(vert_shader, vert_shader_text) gl.glShaderSource(frag_shader, frag_shader_text) gl.glCompileShader(vert_shader) gl.glCompileShader(frag_shader) if not gl.glGetShaderiv(vert_shader, gl.GL_COMPILE_STATUS): print("Vertex shader did not compile") return False if not gl.glGetShaderiv(frag_shader, gl.GL_COMPILE_STATUS): print("Fragment shader did not compile") return False program = gl.glCreateProgram() gl.glAttachShader(program, vert_shader) gl.glAttachShader(program, frag_shader) gl.glLinkProgram(program) gl.glDetachShader(program, vert_shader) gl.glDetachShader(program, frag_shader) gl.glUseProgram(program) if not gl.glGetProgramiv(program, gl.GL_LINK_STATUS): print("Shader not linked") return False # Create and bind buffers # Vertex data buffer vert_dtype = np.dtype([('position', np.float32, 2)]) data = np.zeros(4, dtype=vert_dtype) data['position'] = [(-1, -1), (-1, 1), (1, -1), (1, 1)] stride = data.strides[0] # vb is the vertex buffer vb, pb = gl.glGenBuffers(2) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vb) gl.glBufferData(gl.GL_ARRAY_BUFFER, data.nbytes, data, gl.GL_DYNAMIC_DRAW) offset = ctypes.c_void_p(0) loc = gl.glGetAttribLocation(program, 'position') gl.glEnableVertexAttribArray(loc) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vb) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset) # Offscreen framebuffer for OpenCV fbo = gl.glGenFramebuffers(1) rb = gl.glGenRenderbuffers(1) gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, rb) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_RGBA8, WINDOW_WIDTH, WINDOW_HEIGHT) gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, fbo) gl.glFramebufferRenderbuffer(gl.GL_DRAW_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_RENDERBUFFER, rb) return True
def paintGL(self): """Paint the scene.""" if self.usingA: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureA, 0); else: gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureB, 0); gl.glViewport(0, 0, sparkle_width, sparkle_height) # clear the buffer #gl.glClearColor(255, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT + gl.GL_DEPTH_BUFFER_BIT) gl.glEnableVertexAttribArray(0) gl.glUseProgram(self.shaders_program_fade) gl.glUniform1i(self.fade_texture1, 0) # use GL_TEXTURE0 gl.glUniform1f(self.fade_decay, decay_rate) gl.glEnable(gl.GL_TEXTURE_2D) gl.glActiveTexture(gl.GL_TEXTURE0) if self.usingA: gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB) else: gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA) self.square.bind() gl.glEnableClientState(gl.GL_VERTEX_ARRAY); gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY); gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5*4, None) gl.glTexCoordPointer(2, gl.GL_FLOAT, 5*4, self.square + 3*4) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6) data = np.random.randint(sparkle_width * sparkle_height, size=spikes_per_frame) vbo = glvbo.VBO(data) vbo.bind() self.spike_count += len(data) # tell OpenGL that the VBO contains an array of vertices # prepare the shader gl.glEnableVertexAttribArray(0) # identify what's in the array gl.glVertexAttribPointer(0, 1, gl.GL_UNSIGNED_INT, gl.GL_FALSE, 0, None) gl.glUseProgram(self.shaders_program) # draw "count" points from the VBO gl.glDrawArrays(gl.GL_POINTS, 0, len(data)) gl.glUseProgram(0) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) # unbind the framebuffer gl.glViewport(0, 0, self.width, self.height) gl.glEnable(gl.GL_TEXTURE_2D) gl.glActiveTexture(gl.GL_TEXTURE0) if self.usingA: gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA) else: gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB) self.square.bind() gl.glEnableClientState(gl.GL_VERTEX_ARRAY); gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY); gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5*4, None) gl.glTexCoordPointer(2, gl.GL_FLOAT, 5*4, self.square + 3*4) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 6) self.usingA = not self.usingA now = time.time() if now > self.t_last_msg + 1: dt = now - self.t_last_msg print 'Mspikes per second = %1.1f' % (self.spike_count*0.000001/dt) self.spike_count = 0 self.t_last_msg = now # flag a redraw self.update()
def initializeGL(self): """Initialize OpenGL, VBOs, upload data on the GPU, etc.""" # background color gl.glClearColor(0, 0, 0, 0) vs = glhelpers.compile_vertex_shader(VS) fs = glhelpers.compile_fragment_shader(FS) self.shaders_program = glhelpers.link_shader_program(vs, fs) vs_fade = glhelpers.compile_vertex_shader(VS_fade) fs_fade = glhelpers.compile_fragment_shader(FS_fade) self.shaders_program_fade = glhelpers.link_shader_program(vs_fade, fs_fade) self.fade_texture1 = gl.glGetUniformLocation(self.shaders_program_fade, 'texture1') self.fade_decay = gl.glGetUniformLocation(self.shaders_program_fade, 'decay') # create the texture self.textureA = gl.glGenTextures(1, ['sparkleA']) gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureA) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, sparkle_width, sparkle_height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) self.fbA = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbA); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureA, 0); gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer # create the texture self.textureB = gl.glGenTextures(1, ['sparkleB']) gl.glBindTexture(gl.GL_TEXTURE_2D, self.textureB) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE) gl.glTexParameterf(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, sparkle_width, sparkle_height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None) self.fbB = gl.glGenFramebuffers(1) gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, self.fbB); gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, self.textureA, 0); gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0); # unbind the framebuffer self.square = glvbo.VBO( np.array( [ [ -1,-1, 0, 0, 0 ], [ 1,-1, 0, 1, 0 ], [ 1, 1, 0, 1, 1 ], [ -1,-1, 0, 0, 0 ], [ 1, 1, 0, 1, 1 ], [ -1, 1, 0, 0, 1 ], ],'f') )