Shaders are now referenced as "programs"

Author: einarf

.vscode/launch.json

@@ -12,7 +12,7 @@
             "program": "${workspaceFolder}/manage.py",
             "args": [
                 "runeffect",
-                "examples.warpspeed",
+                "examples.minecraft",
             ],
         },
         {

demosys/conf/__init__.py

@@ -15,7 +15,7 @@
 class Settings:
     SETTINGS_MODULE = None
 
-    SHADER_DIRS = []
+    PROGRAM_DIRS = []
     TEXTURE_DIRS = []
     DATA_DIRS = []
     SCENE_DIRS = []
@@ -61,11 +61,11 @@ def __repr__(self):
             settings_module=self.SETTINGS_MODULE,
         )
 
-    def add_shader_dir(self, directory):
-        """Hack in shader directory"""
-        dirs = list(self.SHADER_DIRS)
+    def add_program_dir(self, directory):
+        """Hack in program directory"""
+        dirs = list(self.PROGRAM_DIRS)
         dirs.append(directory)
-        self.SHADER_DIRS = dirs
+        self.PROGRAM_DIRS = dirs
 
     def add_texture_dir(self, directory):
         """Hack in texture directory"""

demosys/conf/default.py

@@ -43,13 +43,13 @@
 # Otherwise just print the errors to terminal
 SHADER_STRICT_VALIDATION = False
 
-SHADER_DIRS = (
+PROGRAM_DIRS = (
 
 )
 
-SHADER_FINDERS = (
-    "demosys.finders.shaders.FileSystemFinder",
-    "demosys.finders.shaders.EffectDirectoriesFinder",
+PROGRAM_FINDERS = (
+    "demosys.finders.program.FileSystemFinder",
+    "demosys.finders.program.EffectDirectoriesFinder",
 )
 
 TEXTURE_DIRS = (

demosys/deferred/__init__.py

@@ -2,8 +2,8 @@
 
 from demosys.conf import settings
 
-settings.add_shader_dir(
-    os.path.join(os.path.dirname(os.path.abspath(__file__)), 'shaders')
+settings.add_program_dir(
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), 'programs')
 )
 
 from .renderer import DeferredRenderer  # noqa

demosys/deferred/shaders/deferred/combine.glsl renamed to demosys/deferred/programs/deferred/combine.glsl

@@ -65,13 +65,13 @@ def __init__(self, width, height, gbuffer=None, lightbuffer=None):
 
         # Unit cube for point lights (cube with radius 1.0)
         self.unit_cube = geometry.cube(width=2, height=2, depth=2)
-        self.point_light_shader = resources.shaders.get("deferred/light_point.glsl", create=True)
+        self.point_light_shader = resources.programs.get("deferred/light_point.glsl", create=True)
 
         # Debug draw lights
-        self.debug_shader = resources.shaders.get("deferred/debug.glsl", create=True)
+        self.debug_shader = resources.programs.get("deferred/debug.glsl", create=True)
 
         # Combine shader
-        self.combine_shader = resources.shaders.get("deferred/combine.glsl", create=True)
+        self.combine_shader = resources.programs.get("deferred/combine.glsl", create=True)
         self.quad = geometry.quad_fs()
 
     @property

demosys/deferred/shaders/deferred/debug.glsl renamed to demosys/deferred/programs/deferred/debug.glsl

@@ -1,13 +1,14 @@
 import moderngl
-from demosys.effects import effect
 from demosys import geometry
+from demosys.effects import effect
+
 # from pyrr import matrix44
 
 
 class SimpleCubeEffect(effect.Effect):
     """Generated default effect"""
     def __init__(self):
-        self.shader = self.get_shader("cube_plain.glsl", local=True)
+        self.program = self.get_program("cube_plain.glsl", local=True)
         self.cube = geometry.cube(4.0, 4.0, 4.0)
 
     def draw(self, time, frametime, target):
@@ -24,8 +25,8 @@ def draw(self, time, frametime, target):
         m_normal = self.create_normal_matrix(m_mv)
 
         # Draw the cube
-        self.shader.uniform("m_proj", self.sys_camera.projection.tobytes())
-        self.shader.uniform("m_mv", m_mv.astype('f4').tobytes())
-        self.shader.uniform("m_normal", m_normal.astype('f4').tobytes())
-        self.shader.uniform("time", time)
-        self.cube.draw(self.shader)
+        self.program.uniform("m_proj", self.sys_camera.projection.tobytes())
+        self.program.uniform("m_mv", m_mv.astype('f4').tobytes())
+        self.program.uniform("m_normal", m_normal.astype('f4').tobytes())
+        self.program.uniform("time", time)
+        self.cube.draw(self.program)

demosys/deferred/shaders/deferred/geometry_color.glsl renamed to demosys/deferred/programs/deferred/geometry_color.glsl

@@ -1,15 +1,16 @@
 import math
 
+from pyrr import Vector3
+
 import moderngl
 from demosys import geometry
 from demosys.effects import effect
-from pyrr import Vector3
 
 
 class SimpleRaymarchEffect(effect.Effect):
     """Generated raymarching effect"""
     def __init__(self):
-        self.shader = self.get_shader("raymarching_simple.glsl", local=True)
+        self.program = self.get_program("raymarching_simple.glsl", local=True)
 
         # create plane to fit whole screen
         self.plane = geometry.plane_xz(size=self.window.size, resolution=(10, 10))
@@ -35,21 +36,21 @@ def draw(self, time, frametime, target):
 
         # Draw the plane
 
-        # For vertex shader
-        self.shader.uniform("m_proj", self.sys_camera.projection.tobytes())
-        self.shader.uniform("m_mv", m_mv.astype('f4').tobytes())
+        # For vertex program
+        self.program.uniform("m_proj", self.sys_camera.projection.tobytes())
+        self.program.uniform("m_mv", m_mv.astype('f4').tobytes())
 
-        # For fragment shader
-        self.shader.uniform("fov", fov)
-        self.shader.uniform("alpha", alpha)
-        self.shader.uniform("modifier", modifier)
+        # For fragment program
+        self.program.uniform("fov", fov)
+        self.program.uniform("alpha", alpha)
+        self.program.uniform("modifier", modifier)
 
-        self.shader.uniform("cPosition", cPosition.astype('f4').tobytes())
-        self.shader.uniform("cLookAt", cLookAt.astype('f4').tobytes())
-        self.shader.uniform("lPosition", lPosition.astype('f4').tobytes())
-        self.shader.uniform("lIntensity", lItensity)
-        self.shader.uniform("color", color.astype('f4').tobytes())
+        self.program.uniform("cPosition", cPosition.astype('f4').tobytes())
+        self.program.uniform("cLookAt", cLookAt.astype('f4').tobytes())
+        self.program.uniform("lPosition", lPosition.astype('f4').tobytes())
+        self.program.uniform("lIntensity", lItensity)
+        self.program.uniform("color", color.astype('f4').tobytes())
 
-        self.shader.uniform("resolution", (self.window.width, self.window.height))
+        self.program.uniform("resolution", (self.window.width, self.window.height))
 
-        self.plane.draw(self.shader)
+        self.plane.draw(self.program)

demosys/deferred/shaders/deferred/geometry_texture.glsl renamed to demosys/deferred/programs/deferred/geometry_texture.glsl

@@ -1,13 +1,14 @@
+from pyrr import matrix44
+
 import moderngl
-from demosys.effects import effect
 from demosys import geometry
-from pyrr import matrix44
+from demosys.effects import effect
 
 
 class TexturedSphere(effect.Effect):
     """Generated default effect"""
     def __init__(self):
-        self.shader = self.get_shader("default.glsl", local=True)
+        self.program = self.get_program("default.glsl", local=True)
         self.sphere = geometry.sphere(4.0, sectors=32, rings=16)
         self.texture = self.get_texture("wood.jpg", local=True)
 
@@ -27,9 +28,9 @@ def draw(self, time, frametime, target):
         m_normal = self.create_normal_matrix(m_mv)
 
         # Draw the cube
-        self.shader.uniform("m_proj", self.sys_camera.projection.tobytes())
-        self.shader.uniform("m_mv", m_mv.astype('f4').tobytes())
-        self.shader.uniform("m_normal", m_normal.astype('f4').tobytes())
+        self.program.uniform("m_proj", self.sys_camera.projection.tobytes())
+        self.program.uniform("m_mv", m_mv.astype('f4').tobytes())
+        self.program.uniform("m_normal", m_normal.astype('f4').tobytes())
         self.texture.use(location=0)
-        self.shader.uniform("texture0", 0)
-        self.sphere.draw(self.shader)
+        self.program.uniform("texture0", 0)
+        self.sphere.draw(self.program)

demosys/deferred/shaders/deferred/light_point.glsl renamed to demosys/deferred/programs/deferred/light_point.glsl

@@ -101,7 +101,7 @@ def draw(self, time, frametime, target):
     # Methods for getting resources
 
     @local_path
-    def get_shader(self, path, local=False) -> ShaderProgram:
+    def get_program(self, path, local=False) -> ShaderProgram:
         """
         Get a shader or schedule the shader for loading.
         If the resource is not loaded yet, an empty shader object
@@ -111,7 +111,7 @@ def get_shader(self, path, local=False) -> ShaderProgram:
         :param local: Auto-prepend the effect package name to the path
         :return: Shader object
         """
-        return resources.shaders.load(path)
+        return resources.programs.load(path)
 
     @local_path
     def get_texture(self, path, flip=True, local=False, **kwargs) -> moderngl.Texture:

demosys/deferred/renderer.py

@@ -3,15 +3,15 @@
 
 
 class FileSystemFinder(base.BaseFileSystemFinder):
-    """Find shaders in ``SHADER_DIRS``"""
-    settings_attr = 'SHADER_DIRS'
+    """Find shaders in ``PROGRAM_DIRS``"""
+    settings_attr = 'PROGRAM_DIRS'
 
 
 class EffectDirectoriesFinder(base.BaseEffectDirectoriesFinder):
-    """Finds shaders in the registered effects"""
-    directory = 'shaders'
+    """Finds programs in registered effects"""
+    directory = 'programs'
 
 
 def get_finders():
-    for finder in settings.SHADER_FINDERS:
+    for finder in settings.PROGRAM_FINDERS:
         yield base.get_finder(finder)

demosys/effect_templates/cube_simple/effect.py

@@ -1,7 +1,8 @@
 from demosys.loaders.base import BaseLoader
 
 
-class Binary(BaseLoader):
+class Loader(BaseLoader):
+    name = 'binary'
 
     def load(self):
         pass

demosys/effect_templates/cube_simple/shaders/cube_simple/cube_plain.glsl renamed to demosys/effect_templates/cube_simple/programs/cube_simple/cube_plain.glsl

@@ -0,0 +1,8 @@
+from demosys.loaders.base import BaseLoader
+
+
+class Loader(BaseLoader):
+    name = 'json'
+
+    def load(self):
+        pass

demosys/effect_templates/empty/shaders/empty/.gitkeep renamed to demosys/effect_templates/empty/programs/empty/.gitkeep

@@ -0,0 +1,8 @@
+from demosys.loaders.base import BaseLoader
+
+
+class Loader(BaseLoader):
+    name = 'text'
+
+    def load(self):
+        pass

demosys/effect_templates/raymarching_simple/effect.py

@@ -0,0 +1,60 @@
+from demosys import context
+from demosys import resources
+
+
+class Project:
+    """The Project"""
+
+    def __init__(self):
+        self.effects = {}
+        self.programs = {}
+        self.textures = {}
+        self.scenes = {}
+        self.data = {}
+
+    def create_resources(self, external):
+        # Just return the external list
+        return external
+
+    def create_effects(self):
+        pass
+
+    def load(self):
+        resource_list = self.create_resources()
+
+        # Throw each resource into their respective pools
+        for meta in resource_list:
+            resources.add(meta)
+
+        for meta, resource in resources.textures.load_pool():
+            self.textures[meta.label] = resource
+
+        for meta, resource in resources.shaders.load_pool():
+            self.programs[meta.label] = resource
+
+        for meta, resource in resources.scenes.load_pool():
+            self.scenes[meta.label] = resource
+
+        for meta, resource in resources.data.load_pool():
+            self.data[meta.label] = resource
+
+        self.create_effects()
+
+    def get_effect(self, label):
+        return self.effects[label]
+
+    def get_scene(self, label):
+        return self.scenes[label]
+
+    def get_program(self, label):
+        return self.programs[label]
+
+    def get_texture(self, label):
+        return self.textures[label]
+
+    def get_data(self, label):
+        return self.data[label]
+
+    @property
+    def ctx(self):
+        return context.ctx()

demosys/effect_templates/raymarching_simple/shaders/raymarching_simple/raymarching_simple.glsl renamed to demosys/effect_templates/raymarching_simple/programs/raymarching_simple/raymarching_simple.glsl

@@ -1,16 +1,16 @@
-from .shaders import shaders
-from .textures import textures
-from .tracks import tracks  # noqa
-from .scenes import scenes
-from .data import data, Data  # noqa
+from demosys.resources.programs import programs, Program  # noqa
+from demosys.resources.textures import textures
+from demosys.resources.tracks import tracks  # noqa
+from demosys.resources.scenes import scenes
+from demosys.resources.data import data, Data  # noqa
 
 
 def load():
     scenes.load_pool()
-    shaders.load_pool()
+    programs.load_pool()
     textures.load_pool()
     data.load_pool()
 
 
 def count():
-    return scenes.count + shaders.count + textures.count + data.count
+    return scenes.count + programs.count + textures.count + data.count