Rewrite: Isolate GLFW to its own window module

We want to support windows using other packages than glfw including offscreen rendering.

Author: einarf

demosys/context/__init__.py

@@ -1,9 +1,15 @@
 import moderngl
+from .base import Window
 
 # Window instance shortcut
 WINDOW = None  # noqa
 
 
+def window() -> Window:
+    """The window instance we are rendering to"""
+    return WINDOW
+
+
 def ctx() -> moderngl.Context:
-    """Get the moderngl context for the window"""
+    """ModernGL context"""
     return WINDOW.ctx

demosys/context/base.py

@@ -1,17 +1,55 @@
+import sys
+from collections import namedtuple
 
+import moderngl as mgl
+from demosys.conf import settings
 
-class Context:
+GLVersion = namedtuple('GLVersion', ['major', 'minor'])
+
+
+class Window:
+
+    def __init__(self):
+        """
+        Base window intializer
+
+        :param width: window width
+        :param height: window height
+        """
+        self.width = settings.WINDOW['size'][0]
+        self.height = settings.WINDOW['size'][1]
+
+        self.buffer_width = self.width
+        self.buffer_height = self.height
+
+        self.fbo = None
+        self.sys_camera = None
+        self.timer = None
+        self.resources = None
+
+        self.gl_version = GLVersion(*settings.OPENGL['version'])
+        self.resizable = settings.WINDOW.get('resizable') or False
+        self.title = settings.WINDOW.get('title') or "demosys-py"
+        self.aspect_ratio = settings.WINDOW.get('aspect_ratio', 16 / 9)
+
+        self.resizable = settings.WINDOW.get('resizable')
+        self.fullscreen = settings.WINDOW.get('fullscreen')
+        self.vsync = settings.WINDOW.get('vsync')
+        self.cursor = settings.WINDOW.get('cursor')
 
-    def __init__(self, width=0, height=0):
-        # window size
-        self.width = width
-        self.height = height
-        # Actual window buffer size. Needs adjustment for retina and 4k resolution by child
-        self.buffer_width = width
-        self.buffer_height = height
         # ModernGL context
         self.ctx = None
 
+    def clear(self):
+        """Clear the scren"""
+        self.ctx.clear(
+            red=0.0, blue=0.0, green=0.0, alpha=0.0, depth=1.0,
+            viewport=(0, 0, self.buffer_width, self.buffer_height)
+        )
+
+    def viewport(self):
+        self.fbo.use()
+
     def swap_buffers(self):
         """Swap frame buffer"""
         raise NotImplementedError()
@@ -21,12 +59,24 @@ def resize(self, width, height):
         raise NotImplementedError()
 
     def close(self):
-        """Hits the window to close"""
+        """Set the close state"""
         raise NotImplementedError()
 
     def should_close(self):
         """Check if window should close"""
         raise NotImplementedError()
 
     def terminate(self):
+        """Cleanup after close"""
         raise NotImplementedError()
+
+    def print_context_info(self):
+        """Prints out context info"""
+        print("Context Version:")
+        print('ModernGL:', mgl.__version__)
+        print('vendor:', self.ctx.info['GL_VENDOR'])
+        print('renderer:', self.ctx.info['GL_RENDERER'])
+        print('version:', self.ctx.info['GL_VERSION'])
+        print('python:', sys.version)
+        print('platform:', sys.platform)
+        print('code:', self.ctx.version_code)

demosys/context/glfw.py

@@ -1,44 +1,33 @@
-import sys
-
 import glfw
 
 import moderngl as mgl
-from demosys.conf import settings
+from demosys.scene import camera
+from demosys.view import screenshot
 
-from .base import Context
+from .base import Window
 
 
-class GLTFWindow(Context):
+class GLTFWindow(Window):
     min_glfw_version = (3, 2, 1)
 
     def __init__(self):
-        super().__init__(
-            width=settings.WINDOW['size'][0],
-            height=settings.WINDOW['size'][1],
-        )
-        self.resizable = settings.WINDOW.get('resizable') or False
-        self.title = settings.WINDOW.get('title') or "demosys-py"
-        self.aspect_ratio = settings.WINDOW.get('aspect_ratio', 16 / 9)
+        super().__init__()
 
         if not glfw.init():
             raise ValueError("Failed to initialize glfw")
 
         self.check_glfw_version()
 
-        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, settings.OPENGL['version'][0])
-        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, settings.OPENGL['version'][1])
-
+        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, self.gl_version.major)
+        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, self.gl_version.minor)
         glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
         glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
-
-        if not settings.WINDOW.get('resizable'):
-            glfw.window_hint(glfw.RESIZABLE, False)
-
+        glfw.window_hint(glfw.RESIZABLE, self.resizable)
         glfw.window_hint(glfw.DOUBLEBUFFER, True)
         glfw.window_hint(glfw.DEPTH_BITS, 24)
 
         monitor = None
-        if settings.WINDOW.get('fullscreen'):
+        if self.fullscreen:
             # Use the primary monitors current resolution
             monitor = glfw.get_primary_monitor()
             mode = glfw.get_video_mode(monitor)
@@ -53,33 +42,28 @@ def __init__(self):
             glfw.terminate()
             raise ValueError("Failed to create window")
 
-        if not settings.WINDOW.get('cursor'):
+        if not self.cursor:
             glfw.set_input_mode(self.window, glfw.CURSOR, glfw.CURSOR_DISABLED)
 
         # Get the actual buffer size of the window
         # This is important for some displays like Apple's Retina as reported window sizes are virtual
         self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)
         print("Frame buffer size:", self.buffer_width, self.buffer_height)
-
         print("Actual window size:", glfw.get_window_size(self.window))
 
         glfw.make_context_current(self.window)
 
         # The number of screen updates to wait from the time glfwSwapBuffers
         # was called before swapping the buffers and returning
-        if settings.WINDOW.get('vsync'):
+        if self.vsync:
             glfw.swap_interval(1)
 
+        glfw.set_key_callback(self.window, self.key_event_callback)
+        glfw.set_cursor_pos_callback(self.window, self.mouse_event_callback)
+        # glfw.set_window_size_callback(self.window, window_resize_callback)
+
         # Create mederngl context from existing context
         self.ctx = mgl.create_context()
-        print("Context Version:")
-        print('ModernGL:', mgl.__version__)
-        print('vendor:', self.ctx.info['GL_VENDOR'])
-        print('renderer:', self.ctx.info['GL_RENDERER'])
-        print('version:', self.ctx.info['GL_VERSION'])
-        print('python:', sys.version)
-        print('platform:', sys.platform)
-        print('code:', self.ctx.version_code)
 
     def should_close(self):
         return glfw.window_should_close(self.window)
@@ -89,6 +73,7 @@ def close(self):
 
     def swap_buffers(self):
         glfw.swap_buffers(self.window)
+        self.poll_events()
 
     def resize(self, width, height):
         self.width = width
@@ -108,3 +93,95 @@ def check_glfw_version(self):
         print("glfw version: {} (python wrapper version {})".format(glfw.get_version(), glfw.__version__))
         if glfw.get_version() < self.min_glfw_version:
             raise ValueError("Please update glfw binaries to version {} or later".format(self.min_glfw_version))
+
+    def key_event_callback(self, window, key, scancode, action, mods):
+        """
+        Key event callback for glfw
+    s
+        :param window: Window event origin
+        :param key: The keyboard key that was pressed or released.
+        :param scancode: The system-specific scancode of the key.
+        :param action: GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT
+        :param mods: Bit field describing which modifier keys were held down.
+        """
+        # print("Key event:", key, scancode, action, mods)
+
+        # The well-known standard key for quick exit
+        if key == glfw.KEY_ESCAPE:
+            self.close()
+            return
+
+        # Toggle pause time
+        if key == glfw.KEY_SPACE and action == glfw.PRESS:
+            self.timer.toggle_pause()
+
+        # Camera movement
+        # Right
+        if key == glfw.KEY_D:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.RIGHT, True)
+            elif action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.RIGHT, False)
+        # Left
+        elif key == glfw.KEY_A:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.LEFT, True)
+            elif action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.LEFT, False)
+        # Forward
+        elif key == glfw.KEY_W:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.FORWARD, True)
+            if action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.FORWARD, False)
+        # Backwards
+        elif key == glfw.KEY_S:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.BACKWARD, True)
+            if action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.BACKWARD, False)
+
+        # UP
+        elif key == glfw.KEY_Q:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.UP, True)
+            if action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.UP, False)
+
+        # Down
+        elif key == glfw.KEY_E:
+            if action == glfw.PRESS:
+                self.sys_camera.move_state(camera.DOWN, True)
+            if action == glfw.RELEASE:
+                self.sys_camera.move_state(camera.DOWN, False)
+
+        # Screenshots
+        if key == glfw.KEY_X and action == glfw.PRESS:
+            screenshot.create()
+
+        if key == glfw.KEY_R and action == glfw.PRESS:
+            self.resources.shaders.reload()
+
+        # Forward the event to the effect manager
+        self.manager.key_event(key, scancode, action, mods)
+
+    def mouse_event_callback(self, window, xpos, ypos):
+        """
+        Mouse event callback from glfw
+
+        :param window: The window
+        :param xpos: viewport x pos
+        :param ypos: viewport y pos
+        """
+        self.sys_camera.rot_state(xpos, ypos)
+
+    def window_resize_callback(self, window, width, height):
+        """
+        Window resize callback for glfw
+
+        :param window: The window
+        :param width: New width
+        :param height: New height
+        """
+        print("Resize", width, height)
+        self.resize(width, height)

demosys/opengl/fbo.py

@@ -3,33 +3,31 @@
 from demosys import context
 from demosys.opengl import DepthTexture, Texture2D
 
-WINDOW_FBO = None
-
 
 class WindowFBO:
-    """Fake FBO representing default render target"""
-    def __init__(self, window):
-        self.window = window
-        self.ctx = context.ctx()
+    window = None
 
-    def use(self):
+    @classmethod
+    def use(cls):
         """Sets the viewport back to the buffer size of the screen/window"""
         # The expected height with the current viewport width
-        expected_height = int(self.window.buffer_width / self.window.aspect_ratio)
+        expected_height = int(cls.window.buffer_width / cls.window.aspect_ratio)
 
         # How much positive or negative y padding
-        blank_space = self.window.buffer_height - expected_height
+        blank_space = cls.window.buffer_height - expected_height
 
-        self.ctx.screen.use()
-        self.ctx.viewport = (0, blank_space // 2, self.window.buffer_width, expected_height)
+        cls.window.ctx.screen.use()
+        cls.window.ctx.viewport = (0, blank_space // 2, cls.window.buffer_width, expected_height)
 
-    def release(self):
+    @classmethod
+    def release(cls):
         """Dummy release method"""
         pass
 
-    def clear(self, red=0.0, green=0.0, blue=0.0, depth=1.0, viewport=None):
+    @classmethod
+    def clear(cls, red=0.0, green=0.0, blue=0.0, depth=1.0, viewport=None):
         """Dummy clear method"""
-        self.ctx.screen.clear(red=red, green=green, blue=blue, depth=depth, viewport=viewport)
+        cls.ctx.screen.clear(red=red, green=green, blue=blue, depth=depth, viewport=viewport)
 
 
 class FBO:
@@ -167,7 +165,7 @@ def release(self, stack=True):
         :param stack: (bool) If the bind should be popped form the FBO stack.
         """
         if not stack:
-            WINDOW_FBO.use()
+            WindowFBO.use()
             return
 
         # Are we trying to release an FBO that is not bound?
@@ -184,7 +182,7 @@ def release(self, stack=True):
         if FBO._stack:
             parent = FBO._stack[-1]
         else:
-            parent = WINDOW_FBO
+            parent = WindowFBO
 
         # Bind the parent FBO
         if parent: