Clean up ShaderProgram references + docs + tests

Author: einarf

demosys/effects/effect.py

@@ -6,7 +6,6 @@
 import moderngl
 from demosys import resources
 from demosys.context.base import Window  # noqa
-from demosys.opengl import ShaderProgram
 from demosys.scene import camera  # noqa
 from demosys.scene import Scene
 
@@ -78,12 +77,12 @@ def draw(self, time, frametime, target):
 
     # Methods for getting resources
 
-    def get_program(self, label) -> ShaderProgram:
+    def get_program(self, label) -> moderngl.Program:
         """
         Get a program by its label
 
         :param label: The label for the program
-        :return: ShaderProgram object
+        :return: moderngl.Program instance
         """
         return self._project.get_program(label)
 

demosys/opengl/__init__.py

@@ -1,4 +1,3 @@
 from demosys.opengl.draw import texture  # noqa
-from .shader import (ShaderProgram, ShaderError)  # noqa
 from .vao import VAO  # noqa
 from .projection import Projection  # noqa

demosys/opengl/draw.py

@@ -68,83 +68,81 @@ def draw_depth(self, texture, near, far, pos=(0.0, 0.0), scale=(1.0, 1.0)):
     def _init_texture2d_draw(self):
         """Initialize geometry and shader for drawing FBO layers"""
         from demosys import context, geometry  # noqa
-        from demosys.opengl import ShaderProgram  # noqa
 
         if not TextureHelper._quad:
             TextureHelper._quad = geometry.quad_fs()
         # Shader for drawing color layers
-        src = [
-            "#version 330",
-            "#if defined VERTEX_SHADER",
-            "in vec3 in_position;",
-            "in vec2 in_uv;",
-            "out vec2 uv;",
-            "uniform vec2 offset;",
-            "uniform vec2 scale;",
-            "",
-            "void main() {",
-            "    uv = in_uv;"
-            "    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);",
-            "}",
-            "",
-            "#elif defined FRAGMENT_SHADER",
-            "out vec4 out_color;",
-            "in vec2 uv;",
-            "uniform sampler2D texture0;",
-            "void main() {",
-            "    out_color = texture(texture0, uv);",
-            "}",
-            "#endif",
-        ]
-        program = ShaderProgram("fbo_shader")
-        program.set_source("\n".join(src))
-        program.prepare()
-
-        TextureHelper._texture2d_shader = program
+        TextureHelper._texture2d_shader = context.ctx().program(
+            vertex_shader="""
+                #version 330
+
+                in vec3 in_position;
+                in vec2 in_uv;
+                out vec2 uv;
+                uniform vec2 offset;
+                uniform vec2 scale;
+
+                void main() {
+                    uv = in_uv;
+                    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);
+                }
+            """,
+            fragment_shader="""
+                #version 330
+
+                out vec4 out_color;
+                in vec2 uv;
+                uniform sampler2D texture0;
+
+                void main() {
+                    out_color = texture(texture0, uv);
+                }
+            """
+        )
+
         TextureHelper._texture2d_sampler = self.ctx.sampler(
             filter=(moderngl.LINEAR, moderngl.LINEAR),
         )
 
     def _init_depth_texture_draw(self):
         """Initialize geometry and shader for drawing FBO layers"""
         from demosys import context, geometry  # noqa
-        from demosys.opengl import ShaderProgram  # noqa
 
         if not TextureHelper._quad:
             TextureHelper._quad = geometry.quad_fs()
         # Shader for drawing depth layers
-        src = [
-            "#version 330",
-            "#if defined VERTEX_SHADER",
-            "in vec3 in_position;",
-            "in vec2 in_uv;",
-            "out vec2 uv;",
-            "uniform vec2 offset;",
-            "uniform vec2 scale;",
-            "",
-            "void main() {",
-            "    uv = in_uv;"
-            "    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);",
-            "}",
-            "",
-            "#elif defined FRAGMENT_SHADER",
-            "out vec4 out_color;",
-            "in vec2 uv;",
-            "uniform sampler2D texture0;",
-            "uniform float near;"
-            "uniform float far;"
-            "void main() {",
-            "    float z = texture(texture0, uv).r;"
-            "    float d = (2.0 * near) / (far + near - z * (far - near));"
-            "    out_color = vec4(d);",
-            "}",
-            "#endif",
-        ]
-        program = ShaderProgram("depth_shader")
-        program.set_source("\n".join(src))
-        program.prepare()
-
-        TextureHelper._depth_shader = program
+        TextureHelper._depth_shader = context.ctx().program(
+            vertex_shader="""
+                #version 330
+
+                in vec3 in_position;
+                in vec2 in_uv;
+                out vec2 uv;
+                uniform vec2 offset;
+                uniform vec2 scale;
+
+                void main() {
+                    uv = in_uv;
+                    gl_Position = vec4((in_position.xy + vec2(1.0, 1.0)) * scale + offset, 0.0, 1.0);
+                }
+            """,
+            fragment_shader="""
+                #version 330
+
+                out vec4 out_color;
+                in vec2 uv;
+                uniform sampler2D texture0;
+                uniform float near;
+                uniform float far;
+
+                void main() {
+                    float z = texture(texture0, uv).r;
+                    float d = (2.0 * near) / (far + near - z * (far - near));
+                    out_color = vec4(d);
+                }
+            """
+        )
+
         TextureHelper._depth_sampler = self.ctx.sampler(
             filter=(moderngl.LINEAR, moderngl.LINEAR),
             compare_func='',

demosys/opengl/program.py

@@ -1,3 +1,5 @@
+from typing import Tuple, Union
+
 import moderngl
 from demosys.resources.meta import ProgramDescription
 from demosys import context
@@ -144,3 +146,80 @@ def print(self):
 
 class ShaderError(Exception):
     pass
+
+
+class ReloadableProgram:
+    """
+    Programs we want to be reloadabla must be created with this wrapper
+    """
+    def __init__(self, meta: ProgramDescription, program: moderngl.Program):
+        """
+        Create a shader using either a file path or a name
+        :param meta: The ProgramMeta
+        :param program: The program instance
+        """
+        self.program = program
+        self.meta = meta
+
+    @property
+    def name(self):
+        return self.meta.path or self.meta.vertex_shader
+
+    @property
+    def ctx(self) -> moderngl.Context:
+        return self.program.ctx
+
+    def __getitem__(self, key) -> Union[moderngl.Uniform, moderngl.UniformBlock, moderngl.Subroutine,
+                                        moderngl.Attribute, moderngl.Varying]:
+        return self.mglo[key]
+
+    def get(self, key, default):
+        return self.program.get(key, default)
+
+    @property
+    def mglo(self):
+        """The ModernGL Program object"""
+        return self.program.mglo
+
+    @property
+    def glo(self) -> int:
+        """
+        int: The internal OpenGL object.
+        This values is provided for debug purposes only.
+        """
+        return self.program.glo
+
+    @property
+    def subroutines(self) -> Tuple[str, ...]:
+        '''
+            tuple: The subroutine uniforms.
+        '''
+        return self.program.subroutines
+
+    @property
+    def geometry_input(self) -> int:
+        """
+        int: The geometry input primitive.
+        The GeometryShader's input primitive if the GeometryShader exists.
+        The geometry input primitive will be used for validation.
+        """
+        return self.program.geometry_input
+
+    @property
+    def geometry_output(self) -> int:
+        """
+        int: The geometry output primitive.
+        The GeometryShader's output primitive if the GeometryShader exists.
+        """
+        return self.program.geometry_output
+
+    @property
+    def geometry_vertices(self) -> int:
+        """
+        int: The maximum number of vertices that
+        the geometry shader will output.
+        """
+        return self.program.geometry_vertices
+
+    def __repr__(self):
+        return '<ReloadableProgram: {} id={}>'.format(self.name, self.mglo.glo)