Headless rendering support

Author: einarf

demosys/context/__init__.py

@@ -1,11 +1,10 @@
 import moderngl
-from .base import Window
 
 # Window instance shortcut
 WINDOW = None  # noqa
 
 
-def window() -> Window:
+def window() -> 'demosys.context.base.Window':
     """The window instance we are rendering to"""
     return WINDOW
 

demosys/context/base.py

@@ -3,6 +3,8 @@
 
 import moderngl as mgl
 from demosys.conf import settings
+from demosys.opengl.fbo import WindowFBO
+from demosys import context
 
 GLVersion = namedtuple('GLVersion', ['major', 'minor'])
 
@@ -12,10 +14,8 @@ class Window:
     def __init__(self):
         """
         Base window intializer
-
-        :param width: window width
-        :param height: window height
         """
+        self.frames = 0
         self.width = settings.WINDOW['size'][0]
         self.height = settings.WINDOW['size'][1]
 
@@ -26,6 +26,7 @@ def __init__(self):
         self.sys_camera = None
         self.timer = None
         self.resources = None
+        self.manager = None
 
         self.gl_version = GLVersion(*settings.OPENGL['version'])
         self.resizable = settings.WINDOW.get('resizable') or False
@@ -37,26 +38,39 @@ def __init__(self):
         self.vsync = settings.WINDOW.get('vsync')
         self.cursor = settings.WINDOW.get('cursor')
 
+        self._calc_viewport()
+
         # ModernGL context
         self.ctx = None
 
+        WindowFBO.window = self
+        self.fbo = WindowFBO
+        context.WINDOW = self
+
+    def draw(self, current_time, frame_time):
+        self.manager.draw(current_time, frame_time, WindowFBO)
+
     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)
+            viewport=self._viewport,
         )
 
+    def use(self):
+        """Render to this window"""
+        raise NotImplementedError()
+
     def viewport(self):
-        self.fbo.use()
+        self.ctx.viewport = self._viewport
 
     def swap_buffers(self):
         """Swap frame buffer"""
         raise NotImplementedError()
 
     def resize(self, width, height):
         """Resize window"""
-        raise NotImplementedError()
+        self._calc_viewport()
 
     def close(self):
         """Set the close state"""
@@ -70,6 +84,10 @@ def terminate(self):
         """Cleanup after close"""
         raise NotImplementedError()
 
+    def mgl_fbo(self):
+        """Returns the ModernGL fbo used by this window"""
+        raise NotImplementedError()
+
     def print_context_info(self):
         """Prints out context info"""
         print("Context Version:")
@@ -80,3 +98,12 @@ def print_context_info(self):
         print('python:', sys.version)
         print('platform:', sys.platform)
         print('code:', self.ctx.version_code)
+
+    def _calc_viewport(self):
+        """Calculate viewport with correct aspect ratio"""
+        # The expected height with the current viewport width
+        expected_height = int(self.buffer_width / self.aspect_ratio)
+
+        # How much positive or negative y padding
+        blank_space = self.buffer_height - expected_height
+        self._viewport = (0, blank_space // 2, self.buffer_width, expected_height)

demosys/context/glfw.py

@@ -50,6 +50,7 @@ def __init__(self):
         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))
+        self._calc_viewport()
 
         glfw.make_context_current(self.window)
 
@@ -60,18 +61,22 @@ def __init__(self):
 
         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)
+        glfw.set_window_size_callback(self.window, self.window_resize_callback)
 
         # Create mederngl context from existing context
         self.ctx = mgl.create_context()
 
+    def use(self):
+        self.ctx.screen.use()
+
     def should_close(self):
         return glfw.window_should_close(self.window)
 
     def close(self):
         glfw.set_window_should_close(self.window, True)
 
     def swap_buffers(self):
+        self.frames += 1
         glfw.swap_buffers(self.window)
         self.poll_events()
 
@@ -80,10 +85,14 @@ def resize(self, width, height):
         self.height = height
         self.buffer_width, self.buffer_height = glfw.get_framebuffer_size(self.window)
         print("Resize:", self.width, self.height, self.buffer_width, self.buffer_height)
+        super().resize(width, height)
 
     def terminate(self):
         glfw.terminate()
 
+    def mgl_fbo(self):
+        return self.ctx.screen
+
     def poll_events(self):
         """Poll events from glfw"""
         glfw.poll_events()

demosys/context/headless.py

@@ -0,0 +1,52 @@
+import moderngl
+from demosys.conf import settings
+from demosys.conf import ImproperlyConfigured
+from demosys.opengl.fbo import FBO
+
+from .base import Window
+
+
+class HeadlessWindow(Window):
+
+    def __init__(self):
+        super().__init__()
+
+        self.headless_frames = getattr(settings, 'HEADLESS_FRAMES', 0)
+        self.headless_duration = getattr(settings, 'HEADLESS_DURATION', 0)
+
+        if not self.headless_frames and not self.headless_duration:
+            raise ImproperlyConfigured("HEADLESS_DURATION or HEADLESS_FRAMES not present in settings")
+
+        self._close = False
+        self.ctx = moderngl.create_standalone_context()
+        self.screenbuffer = FBO.create((self.width, self.height), depth=True)
+
+    def draw(self, current_time, frame_time):
+        super().draw(current_time, frame_time)
+
+        if self.headless_duration and current_time >= self.headless_duration:
+            self.close()
+
+    def use(self):
+        self.screenbuffer.use(stack=False)
+
+    def should_close(self):
+        return self._close
+
+    def close(self):
+        self._close = True
+
+    def resize(self, width, height):
+        pass
+
+    def swap_buffers(self):
+        self.frames += 1
+
+        if self.headless_frames and self.frames >= self.headless_frames:
+            self.close()
+
+    def terminate(self):
+        pass
+
+    def mgl_fbo(self):
+        return self.screenbuffer.mglo

demosys/opengl/fbo.py

@@ -10,14 +10,8 @@ class WindowFBO:
     @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(cls.window.buffer_width / cls.window.aspect_ratio)
-
-        # How much positive or negative y padding
-        blank_space = cls.window.buffer_height - expected_height
-
-        cls.window.ctx.screen.use()
-        cls.window.ctx.viewport = (0, blank_space // 2, cls.window.buffer_width, expected_height)
+        cls.window.use()
+        cls.window.viewport()
 
     @classmethod
     def release(cls):
@@ -27,7 +21,13 @@ def release(cls):
     @classmethod
     def clear(cls, red=0.0, green=0.0, blue=0.0, depth=1.0, viewport=None):
         """Dummy clear method"""
-        cls.ctx.screen.clear(red=red, green=green, blue=blue, depth=depth, viewport=viewport)
+        cls.window.clear()
+
+    @property
+    @classmethod
+    def mglo(cls):
+        """Internal ModernGL fbo"""
+        return cls.window.mgl_fbo()
 
 
 class FBO:
@@ -224,6 +224,10 @@ def __repr__(self):
             self.depth_buffer,
         )
 
+    @property
+    def mglo(self):
+        """Internal ModernGL fbo"""
+        return self.fbo
 
 class FBOError(Exception):
     """Generic FBO Error"""

demosys/view/controller.py

@@ -8,10 +8,9 @@
 import OpenGL
 OpenGL.ERROR_CHECKING = False  # noqa
 
-from demosys import context, resources
+from demosys import resources
 from demosys.conf import settings
 from demosys.effects.registry import Effect
-from demosys.opengl.fbo import WindowFBO
 from demosys.scene import camera
 from demosys.utils import module_loading
 
@@ -26,24 +25,19 @@ def run(manager=None):
     print("window class", window_cls_name)
     window_cls = module_loading.import_string(window_cls_name)
     window = window_cls()
-
-    window.manager = manager
-    context.WINDOW = window
     window.print_context_info()
-
-    WindowFBO.window = window
-    window.fbo = WindowFBO
+    window.manager = manager
 
     print("Loader started at", time.time())
 
     # Inject attributes into the base Effect class
-    setattr(Effect, '_window_width', context.WINDOW.buffer_width)
-    setattr(Effect, '_window_height', context.WINDOW.buffer_height)
-    setattr(Effect, '_window_aspect', context.WINDOW.aspect_ratio)
-    setattr(Effect, '_ctx', context.ctx())
+    setattr(Effect, '_window_width', window.buffer_width)
+    setattr(Effect, '_window_height', window.buffer_height)
+    setattr(Effect, '_window_aspect', window.aspect_ratio)
+    setattr(Effect, '_ctx', window.ctx)
 
     # Set up the default system camera
-    window.sys_camera = camera.SystemCamera(aspect=context.WINDOW.aspect_ratio, fov=60.0, near=1, far=1000)
+    window.sys_camera = camera.SystemCamera(aspect=window.aspect_ratio, fov=60.0, near=1, far=1000)
     setattr(Effect, '_sys_camera', window.sys_camera)
 
     # Initialize Effects
@@ -66,22 +60,20 @@ def run(manager=None):
     window.timer.start()
 
     # Main loop
-    frames, frame_time = 0, 60.0 / 1000.0
+    frame_time = 60.0 / 1000.0
     # time_start = glfw.get_time()
     time_start = time.time()
     prev_time = window.timer.get_time()
 
     while not window.should_close():
         current_time = window.timer.get_time()
 
+        window.use()
         window.viewport()
         window.clear()
-
-        manager.draw(current_time, frame_time, WindowFBO)
-
+        window.draw(current_time, frame_time)
         window.swap_buffers()
 
-        frames += 1
         frame_time = current_time - prev_time
         prev_time = current_time
 
@@ -91,6 +83,6 @@ def run(manager=None):
     window.terminate()
 
     if duration > 0:
-        fps = round(frames / duration, 2)
-        print("Duration: {}s rendering {} frames at {} fps".format(duration, frames, fps))
+        fps = round(window.frames / duration, 2)
+        print("Duration: {}s rendering {} frames at {} fps".format(duration, window.frames, fps))
         print("Timeline duration:", duration_timer)

demosys/view/screenshot.py

@@ -28,7 +28,7 @@ def create(file_format='png', name=None):
         print("SCREENSHOT_PATH not defined in settings. Using cwd as fallback.")
 
     if not Config.target:
-        Config.target = context.ctx().screen
+        Config.target = context.window().mgl_fbo()
 
     image = Image.frombytes(
         "RGB",