Merge branch 'master' into samplers

Author: einarf

demosys/context/base.py

@@ -3,8 +3,6 @@
 
 import moderngl
 from demosys.conf import settings
-from demosys.opengl.fbo import WindowFBO
-from demosys import context
 
 GLVersion = namedtuple('GLVersion', ['major', 'minor'])
 
@@ -38,41 +36,41 @@ def __init__(self):
         self.vsync = settings.WINDOW.get('vsync')
         self.cursor = settings.WINDOW.get('cursor')
 
-        self._calc_viewport()
+        self.clear_color = (0.0, 0.0, 0.0, 0.0)
+        self.clear_depth = (1.0)
 
         # 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)
+        self.set_default_viewport()
+        self.manager.draw(current_time, frame_time, self.fbo)
 
     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=self._viewport,
+        self.ctx.screen.clear(
+            red=self.clear_color[0],
+            green=self.clear_color[1],
+            blue=self.clear_color[2],
+            alpha=self.clear_color[3],
+            depth=self.clear_depth,
         )
 
+    def clear_values(self, red=0.0, green=0.0, blue=0.0, alpha=0.0, depth=1.0):
+        self.clear_color = (red, green, blue, alpha)
+        self.clear_depth = depth
+
     def use(self):
         """Render to this window"""
         raise NotImplementedError()
 
-    def viewport(self):
-        self.ctx.viewport = self._viewport
-
     def swap_buffers(self):
         """Swap frame buffer"""
         raise NotImplementedError()
 
     def resize(self, width, height):
         """Resize window"""
-        self.width = width
-        self.height = height
-        self._calc_viewport()
+        self.set_default_viewport()
 
     def close(self):
         """Set the close state"""
@@ -87,8 +85,7 @@ def terminate(self):
         raise NotImplementedError()
 
     def mgl_fbo(self):
-        """Returns the ModernGL fbo used by this window"""
-        raise NotImplementedError()
+        return self.ctx.screen
 
     def print_context_info(self):
         """Prints out context info"""
@@ -101,11 +98,11 @@ def print_context_info(self):
         print('platform:', sys.platform)
         print('code:', self.ctx.version_code)
 
-    def _calc_viewport(self):
+    def set_default_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)
+        self.ctx.screen.viewport = (0, blank_space // 2, self.buffer_width, expected_height)

demosys/context/glfw.py

@@ -3,7 +3,8 @@
 import moderngl
 from demosys.scene import camera
 from demosys.view import screenshot
-
+from demosys.opengl import FBO
+from demosys import context
 from .base import Window
 
 
@@ -50,7 +51,6 @@ 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)
 
@@ -65,6 +65,11 @@ def __init__(self):
 
         # Create mederngl context from existing context
         self.ctx = moderngl.create_context()
+        self.fbo = FBO()
+        self.fbo.fbo = self.ctx.screen
+        self.fbo.default_framebuffer = True
+        context.WINDOW = self
+        self.set_default_viewport()
 
     def use(self):
         self.ctx.screen.use()
@@ -90,9 +95,6 @@ def resize(self, 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()
@@ -106,7 +108,7 @@ def check_glfw_version(self):
     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.

demosys/opengl/fbo.py

@@ -4,32 +4,6 @@
 from demosys.opengl import DepthTexture, Texture2D
 
 
-class WindowFBO:
-    window = None
-
-    @classmethod
-    def use(cls):
-        """Sets the viewport back to the buffer size of the screen/window"""
-        cls.window.use()
-        cls.window.viewport()
-
-    @classmethod
-    def release(cls):
-        """Dummy release method"""
-        pass
-
-    @classmethod
-    def clear(cls):
-        """Dummy clear method"""
-        cls.window.clear()
-
-    @property
-    @classmethod
-    def mglo(cls):
-        """Internal ModernGL fbo"""
-        return cls.window.mgl_fbo()
-
-
 class FBO:
     """
     A framebuffer object is a collection of buffers that can be used as the destination for rendering.
@@ -41,9 +15,11 @@ class FBO:
     _stack = []
 
     def __init__(self):
+        self._window = context.window()
         self.color_buffers = []
         self.depth_buffer = None
         self.fbo = None
+        self.default_framebuffer = False
 
     @staticmethod
     def create_from_textures(color_buffers: List[Texture2D], depth_buffer: DepthTexture = None) -> 'FBO':
@@ -169,7 +145,8 @@ def use(self, stack=True):
         if not stack:
             return
 
-        FBO._stack.append(self)
+        if not self.default_framebuffer:
+            FBO._stack.append(self)
 
         if len(FBO._stack) > 8:
             raise FBOError("FBO stack overflow. You probably forgot to release a bind somewhere.")
@@ -180,8 +157,11 @@ def release(self, stack=True):
 
         :param stack: (bool) If the bind should be popped form the FBO stack.
         """
+        if self.default_framebuffer:
+            return
+
         if not stack:
-            WindowFBO.use()
+            self._window.fbo.use()
             return
 
         # Are we trying to release an FBO that is not bound?
@@ -198,7 +178,7 @@ def release(self, stack=True):
         if FBO._stack:
             parent = FBO._stack[-1]
         else:
-            parent = WindowFBO
+            parent = self._window.fbo
 
         # Bind the parent FBO
         if parent:

demosys/text/resources/shaders/demosys/text/textwriter2d.glsl

@@ -0,0 +1,74 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in uint in_char_id;
+
+uniform vec2 char_size;
+
+out uint vs_char_id;
+
+void main() {
+	gl_Position = vec4(in_position + vec3(gl_InstanceID * char_size.x, 0.0, 0.0), 1.0);
+    vs_char_id = in_char_id;
+}
+
+#elif defined GEOMETRY_SHADER
+
+layout (points) in;
+layout (triangle_strip, max_vertices = 4) out;
+
+uniform mat4 m_proj;
+uniform vec2 text_pos;
+uniform vec2 char_size;
+
+in uint vs_char_id[1];
+out vec2 uv;
+flat out uint gs_char_id;
+
+void main() {
+    vec3 pos = gl_in[0].gl_Position.xyz + vec3(text_pos, 0.0);
+
+    vec3 right = vec3(1.0, 0.0, 0.0) * char_size.x / 2.0;
+    vec3 up = vec3(0.0, 1.0, 0.0) * char_size.y / 2.0;
+
+    // upper right
+    uv = vec2(1.0, 1.0);
+    gs_char_id = vs_char_id[0];
+    gl_Position = m_proj * vec4(pos + (right + up), 1.0);
+    EmitVertex();
+
+    // upper left
+    uv = vec2(0.0, 1.0);
+    gs_char_id = vs_char_id[0];
+    gl_Position = m_proj * vec4(pos + (-right + up), 1.0);
+    EmitVertex();
+
+    // lower right
+    uv = vec2(1.0, 0.0);
+    gs_char_id = vs_char_id[0];
+    gl_Position = m_proj * vec4(pos + (right - up), 1.0);
+    EmitVertex();
+
+    // lower left
+    uv = vec2(0.0, 0.0);
+    gs_char_id = vs_char_id[0];
+    gl_Position = m_proj * vec4(pos + (-right - up), 1.0);
+    EmitVertex();
+
+    EndPrimitive();
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform sampler2DArray font_texture;
+in vec2 uv;
+flat in uint gs_char_id;
+
+void main()
+{
+    fragColor = texture(font_texture, vec3(uv, gs_char_id));
+}
+#endif

…ces/shaders/demosys/text/textwriter.glsl …s/shaders/demosys/text/textwriter3d.glsldemosys/text/resources/shaders/demosys/text/textwriter.glsl renamed to demosys/text/resources/shaders/demosys/text/textwriter3d.glsl demosys/text/resources/shaders/demosys/text/textwriter.glsl renamed to demosys/text/resources/shaders/demosys/text/textwriter3d.glsl

@@ -1,28 +1,32 @@
 import numpy
+
 import moderngl
-from demosys.opengl import VAO
+from demosys.opengl import VAO, TextureArray
 from demosys.resources import data, shaders, textures
-from demosys.opengl import TextureArray
+from pyrr import matrix44
 
 from .base import BaseText, Meta
 
 
 class TextWriter2D(BaseText):
 
-    def __init__(self, area, size=0.1, text=""):
+    def __init__(self, area, text="", aspect_ratio=1.0):
         """
         :param area: (x, y) Text area size (number of characters)
         :param size: Text size
         :param text: Initial text
         """
         super().__init__()
         self.area = area
-        self.size = size
         self._text = text.encode('latin1')
 
+        self.projection_bytes = None
+        self._aspect_ratio = 1.0
+        self.aspect_ratio = aspect_ratio
+
         self._vao = None
         self._texture = textures.get('demosys/text/VeraMono.png', cls=TextureArray, layers=190, create=True)
-        self._shader = shaders.get('demosys/text/textwriter.glsl', create=True)
+        self._shader = shaders.get('demosys/text/textwriter2d.glsl', create=True)
         self._config = data.get('demosys/text/meta.json', create=True)
 
         data.on_loaded(self._post_load)
@@ -49,11 +53,36 @@ def text(self):
     def text(self, value):
         self._text = value
 
-    def draw(self, proj_matrix, view_matrix):
-        # print(self._text, self._string_data)
+    @property
+    def aspect_ratio(self):
+        return self._aspect_ratio
+
+    @aspect_ratio.setter
+    def aspect_ratio(self, value):
+        self._aspect_ratio = value
+        self.projection_bytes = matrix44.create_orthogonal_projection_matrix(
+            -self.aspect_ratio,  # left
+            self.aspect_ratio,  # right
+            -1.0,  # bottom
+            1.0,  # top
+            -100.0,  # near
+            100.0,  # far
+            dtype=numpy.float32,
+        ).tobytes()
+
+    def draw(self, pos, size=1.0):
+        csize = (
+            self._meta.character_width / self._meta.character_height * size,
+            1.0 * size,
+        )
+        cpos = (
+            pos[0] - self._aspect_ratio + csize[0] / 2,
+            -pos[1] + 1.0 - csize[1] / 2,
+        )
+
         self._texture.use(location=0)
-        self._shader.uniform("m_proj", proj_matrix.astype('f4').tobytes())
-        self._shader.uniform("m_mv", view_matrix.astype('f4').tobytes())
+        self._shader.uniform("m_proj", self.projection_bytes)
+        self._shader.uniform("text_pos", cpos)
         self._shader.uniform("font_texture", 0)
-        self._shader.uniform("char_size", (self._meta.character_width / self._meta.character_height, 1.0))
+        self._shader.uniform("char_size", csize)
         self._vao.draw(self._shader, instances=len(self._string_data))