Esempio n. 1
0
 def hide_window(self):
     '''
     Hides renderer window
     :return: None
     '''
     self.is_window_hidden = True
     glfw.hide_window(self.__window)
     glfw.poll_events()
Esempio n. 2
0
 def _monitor_event(self, monitor, event):
     name = glfw.get_monitor_name(monitor)
     if event == glfw.DISCONNECTED:
         logger.info("Unplugged monitor {}".format(name))
     else:
         logger.info("Plugged monitor {}".format(name))
     self.pano_renderer.enableOutput(False)
     if self.output_window:
         glfw.hide_window(self.output_window)
     async .delay(SWITCH_DELAY, self.open_output_window)
Esempio n. 3
0
 def _vispy_set_visible(self, visible):
     # Show or hide the window or widget
     if self._id is None:
         return
     if visible:
         glfw.show_window(self._id)
         # this ensures that the show takes effect
         self._vispy_update()
     else:
         glfw.hide_window(self._id)
Esempio n. 4
0
    def __init__(self, resolution=(800, 600), hidden=True):
        if self._run_init:
            self._run_init = False
        else:
            return

        if not glfw.init():
            raise RuntimeError("Failed to initialize GLFW.")

        self.hidden = hidden
        self.resolution = resolution
        self.vao_id = 0
        self.vert_vbo_id = 0
        self.color_vbo_id = 0
        self.vertex_buffer = None
        self.color_buffer = None
        self.frame_buffer = None
        self.result_texture = None
        self.n_verts = 0

        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
        glfw.window_hint(glfw.RESIZABLE, False)

        self.window = glfw.create_window(resolution[0], resolution[1],
                                         "Renderer", None, None)
        if not self.window:
            glfw.terminate()
            raise RuntimeError("Failed to create GLFW context.")
        glfw.make_context_current(self.window)

        if hidden:
            glfw.hide_window(self.window)

        self._init_alpha()
        self._init_frame_buffer_objects()

        with open("shaders/vertex.glsl") as vs:
            vertex_shader = shaders.compileShader(vs.read(), GL_VERTEX_SHADER)
        with open("shaders/fragment.glsl") as fs:
            fragment_shader = shaders.compileShader(fs.read(),
                                                    GL_FRAGMENT_SHADER)
        self.program = shaders.compileProgram(vertex_shader, fragment_shader)
        with self.program:
            uloc = glGetUniformLocation(self.program,
                                        'screen_to_standard_transform')
            T = self._screen_to_clip()
            glUniformMatrix3fv(uloc, 1, True, T)

        self.vao_id = self._init_vao()
Esempio n. 5
0
    def __close_window(self, window):
        """
        if not joined, glfw function can be called where there is no glfw context
        anymore. Downside of joining is that window destruction will only occur
        when draw waiting is over - meaning destruction only takes place after a frame
        this can cause 'noticable stall' when fps is very low

        to detour this problem, window is hidden before actually being destroyed
        :param window:
        :return:
        """
        with self.__context.glfw as window:
            glfw.hide_window(window)  # <- glfw window still alive here
            self._render_thread.join()
            self.__context.context_master.remove_window(self)
            glfw.destroy_window(window)  # <- window destoied here
Esempio n. 6
0
    def open_output_window(self):
        self._pause_event_loop()

        # Select monitor
        self._select_monitor()

        # Open window
        if self.monitor:
            # Fullscreen
            self._select_video_mode()
            x, y = glfw.get_monitor_pos(self.monitor)
            logger.info("Output selected : {} on {} at {},{}".format(
                str(self.video_mode), glfw.get_monitor_name(self.monitor), x,
                y))
            w, h = self.video_mode[0]
            self.pano_renderer.setViewport(w, h)
            self.pano_renderer.setRefreshRate(
                self._convert_rate(30), self._convert_rate(self.video_mode[2]))
            if self.output_window:
                glfw.set_window_monitor(self.output_window, self.monitor, x, y,
                                        w, h, self.video_mode[2])
                glfw.show_window(self.output_window)
                self.pano_renderer.enableOutput(True)
            else:
                self._open_output_window(w, h, self.monitor, self.video_mode)
        else:
            # No monitor available or windowed
            w = self.width / 4
            h = self.height / 4
            self.pano_renderer.setViewport(w, h)

            monitor = glfw.get_primary_monitor()
            if monitor:
                rate = glfw.get_video_mode(monitor)[2]
                self.pano_renderer.setRefreshRate(self._convert_rate(30),
                                                  self._convert_rate(rate))

            if self.output_window:
                self.pano_renderer.enableOutput(True)
                glfw.show_window(self.output_window)
            else:
                self._open_output_window(w, h)
                if not SETTINGS.display in ["window", "windowed"]:
                    # No monitor available
                    glfw.hide_window(self.output_window)

        self._unpause_event_loop()
Esempio n. 7
0
    def __init__(self, name, size, show=True):
        self.size = size
        
        # window setup
        if not glfw.init():
            raise RuntimeError('Failed to initialize GLFW')
        
        self.window = glfw.create_window(size[0], size[1], name, None, None)
        
        if not show:
            glfw.hide_window(self.window) # hide window
        
        if not self.window:
            glfw.terminate()
            raise RuntimeError('Failed to create window')

        # set context
        glfw.make_context_current(self.window)
        
        # init Syhon
        self.server = syphonpy.SyphonServer(name)
        
        # OpenGL init
        glMatrixMode(GL_PROJECTION)
        glOrtho(0, size[0], size[1], 0, 1, -1)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        glDisable(GL_DEPTH_TEST)
        glClearColor(0.0, 0.0, 0.0, 0.0)
        glEnable(GL_TEXTURE_2D)
        
        # create texture id for use with Syphon
        self.TextureID = glGenTextures(1)
        
        # initalise our sender texture
        glBindTexture(GL_TEXTURE_2D, self.TextureID)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
        glBindTexture(GL_TEXTURE_2D, 0)
 def _on_close(self, *args):
     print("closing")
     all_glfw_canvases.discard(self)
     glfw.hide_window(self._window)
Esempio n. 9
0
 def _on_close(self, *args):
     all_glfw_canvases.discard(self)
     glfw.hide_window(self._window)
Esempio n. 10
0
    def draw(self, return_mat=False):
        if self.client:
            img = self.client.new_frame_image()
        
        if img and img.texture_size().width and img.texture_size().height:
            if self.first_frame_flg:
                # set window size and show option
                glfw.set_window_size(self.window, int(img.texture_size().width), int(img.texture_size().height))
                if not self.show:
                    glfw.hide_window(self.window) # hide window
                    
                # OpenGL init
                glMatrixMode(GL_PROJECTION)
                glOrtho(0, int(img.texture_size().width), int(img.texture_size().height), 0, 1, -1)
                glMatrixMode(GL_MODELVIEW)
                glLoadIdentity()
                glDisable(GL_DEPTH_TEST)
                glClearColor(0.0, 0.0, 0.0, 0.0)
                glEnable(GL_TEXTURE_RECTANGLE)
                
                self.first_frame_flg = False

                print(f"server: \"{self.server.app_name}/{self.server.name}\", window: \"{self.window_name}\", size: \"{img.texture_size().width} × {img.texture_size().height}\"")
            
            glfw.make_context_current(self.window)
            
            # Clear screen
            glClearColor(0.0, 0.0, 0.0, 0.0)
            glClear(GL_COLOR_BUFFER_BIT)
            
            #  Bind the texture
            glEnable(GL_TEXTURE_RECTANGLE)
            glActiveTexture(GL_TEXTURE0)
            glBindTexture(GL_TEXTURE_RECTANGLE, img.texture_name())
            
            #  Configure texturing as we want it
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP)
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP)
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
            glEnable(GL_BLEND)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
            
            glColor4f(1.0, 1.0, 1.0, 1.0)
            
            texCoords = np.array([
                0.0, img.texture_size().height, 
                img.texture_size().width, img.texture_size().height, 
                img.texture_size().width, 0.0, 
                0.0, 0.0], dtype=GLfloat)

            verts = np.array([
                0.0, 0.0, 
                img.texture_size().width, 0.0, 
                img.texture_size().width, img.texture_size().height, 
                0.0, img.texture_size().height], dtype=GLfloat)
            
            glEnableClientState( GL_TEXTURE_COORD_ARRAY )
            glTexCoordPointer(2, GL_FLOAT, 0, texCoords)
            glEnableClientState(GL_VERTEX_ARRAY)
            glVertexPointer(2, GL_FLOAT, 0, verts)
            glDrawArrays( GL_TRIANGLE_FAN, 0, 4 )
            
            if return_mat:
                x_scale, y_scale = glfw.get_window_content_scale(self.window)
                frame = np.zeros((int(img.texture_size().height * x_scale), int(img.texture_size().width * y_scale), 4), np.uint8)
                glPixelStorei(GL_PACK_ALIGNMENT, 1)
                glPixelStorei(GL_PACK_ROW_LENGTH, (int(img.texture_size().width * x_scale)))
               
                glReadPixels(0, 0, int(img.texture_size().width * x_scale), int(img.texture_size().height * y_scale), GL_BGRA, GL_UNSIGNED_BYTE, frame.data)
                frame = cv2.resize(frame, (int(img.texture_size().width), int(img.texture_size().height)))
                frame = cv2.flip(frame, 0)
                return frame
            
        glfw.swap_buffers(self.window)
        glfw.poll_events()
        
        # unbind our sender texture
        glBindTexture(GL_TEXTURE_RECTANGLE, 0)