Resource pool rewrites

Author: einarf

demosys/opengl/shader.py

@@ -153,15 +153,15 @@ def prepare(self, reload=False):
         program = self.ctx.program(**params)
 
         if reload:
-            self.program.release()
+            self.release()
 
         self.program = program
 
         # Build internal lookups
         self._build_uniform_map()
         self._build_attribute_map()
 
-    def _delete(self):
+    def release(self):
         """Frees the memory and invalidates the name associated with the program"""
         if self.program:
             self.program.release()

demosys/resources/shaders.py

@@ -10,91 +10,86 @@
 from .base import BaseRegistry
 
 
+class ShaderMeta:
+
+    def __init__(self, path, **kwargs):
+        self.path = path
+        self.kwargs = kwargs
+
+
 class Shaders(BaseRegistry):
     """
     A registry for shaders requested by effects.
     Once all effects are initialized, we ask this class to load the shaders.
     """
     def __init__(self):
         super().__init__()
-        self.shaders = {}
-
-    @property
-    def count(self):
-        """
-        :return: Number of shaders
-        """
-        return len(self.shaders)
 
-    def get(self, path: Union[str, Path], create=False) -> ShaderProgram:
+    def load(self, path: Union[str, Path], **kwargs) -> ShaderProgram:
         """
-        Get or create a shader object.
-        This may return an empty object that will be filled during load
-        based on the ``create`` parameter.
+        load shader program or return an exiting program.
 
         :param path: Path to the shader (pathlib.Path instance)
-        :param create: (bool) Create an empty shader object if it doesn't exist
         :return: Shader object
         """
         path = Path(path)
 
-        shader = self.shaders.get(path)
-        if create and not shader:
-            shader = ShaderProgram(path)
-            self.shaders[path] = shader
+        shader = self.file_map.get(path)
+        if shader:
+            return shader
+
+        meta = self.load_deferred(path, **kwargs)
+        shader = self._load(meta)
+
         return shader
 
-    def load(self, reload=False):
-        """
-        Loads all the shaders using the configured finders.
+    def load_deferred(self, path: Union[str, Path], **kwargs) -> ShaderMeta:
+        meta = ShaderMeta(path, **kwargs)
 
-        :param reload: (bool) Are we reloading the shaders?
-        """
-        print("Loading shaders:")
-        for name, shader in self.shaders.items():
-            self.load_shader(shader, name=name, reload=reload)
+        self.file_map[path] = None
+        self.file_meta[path] = meta
 
-        self._on_loaded()
+        return meta
 
-    def load_shader(self, shader, name=None, reload=False):
-        """
-        Loads a single shader adding it to the shader registry
+    def _load(self, meta, reload=False):
+        found_path = self._find_last_of(meta.path, list(get_finders()))
 
-        :param shader: The shader to load
-        :param name: Unique name in the registry. Usually the path
-        :param reload: (bool) Are we reloading the shader?
-        """
-        if name is None:
-            name = Path(shader.path)
-
-        finders = list(get_finders())
-
-        for finder in finders:
-            path = finder.find(name)
-            if path:
-                print(" - {}".format(path))
-                with open(path, 'r') as fd:
-                    shader.set_source(fd.read())
-
-                try:
-                    shader.prepare(reload=reload)
-                except (ShaderError, moderngl.Error) as err:
-                    print("ShaderError: ", err)
-                    if not reload:
-                        raise
-                except Exception as err:
-                    print(err)
-                    raise
-
-                break
+        if not found_path:
+            raise ImproperlyConfigured("Cannot find shader {}".format(meta.path))
+
+        print("Loading: {}".format(meta.path))
+        if reload:
+            shader = self.file_map[meta.path]
         else:
-            raise ImproperlyConfigured("Cannot find shader {}".format(name))
+            shader = ShaderProgram(meta.path)
+
+        with open(found_path, 'r') as fd:
+            shader.set_source(fd.read())
+
+        try:
+            shader.prepare(reload=reload)
+        except (ShaderError, moderngl.Error) as err:
+            print("ShaderError: ", err)
+            if not reload:
+                raise
+        except Exception as err:
+            print(err)
+            raise
+
+        self.file_map[meta.path] = shader
+
+        return shader
+
+    def _destroy(self, obj):
+        obj.release()
 
     def reload(self):
         """
         Reloads all shaders
         """
-        self.load(reload=True)
+        for path, meta in self.file_meta.items():
+            print(path, meta)
+            self._load(meta, reload=True)
 
 
 shaders = Shaders()

demosys/resources/textures.py

@@ -11,59 +11,69 @@
 from .base import BaseRegistry
 
 
+class TextureMeta:
+
+    def __init__(self, path, cls, **kwargs):
+        self.path = path
+        self.cls = cls
+        self.kwargs = kwargs
+
+
 class Textures(BaseRegistry):
     """
     A registry for textures requested by effects.
     Once all effects are initialized, we ask this class to load the textures.
     """
     def __init__(self):
         super().__init__()
-        self.textures = {}
-
-    @property
-    def count(self):
-        """
-        :return: Number of textures
-        """
-        return len(self.textures)
 
-    def get(self, path: Union[str, Path], create=False, cls=Texture2D, **kwargs) -> Union[Texture2D, TextureArray]:
+    def load(self, path: Union[str, Path], cls=Texture2D, **kwargs) -> Union[Texture2D, TextureArray]:
         """
         Get or create a texture object.
-        This may return an empty object that will be filled during load
-        based on the ``create`` parameter.
+        This may return an empty object that will be filled during loading stage
 
         :param path: Path to the texture
-        :param create: (bool) Create an empty texture object if it doesn't exist
         :param cls: The texture class to instantiate
         :return: Texture object
         """
         path = Path(path)
 
-        texture = self.textures.get(path)
-        if create and not texture:
-            texture = cls(path=path, **kwargs)
-            self.textures[path] = texture
+        texture = self.file_map.get(path)
+        if texture:
+            return texture
+
+        meta = self.load_deferred(path, cls=cls, **kwargs)
+        texture = self._load(meta)
+
         return texture
 
-    def load(self):
+    def load_deferred(self, path: Union[str, Path], cls=Texture2D, **kwargs) -> TextureMeta:
+        meta = TextureMeta(path, cls, **kwargs)
+
+        self.file_map[path] = None
+        self.file_meta[path] = meta
+
+        return meta
+
+    def _load(self, meta):
         """
         Loads all the textures using the configured finders.
         """
-        finders = list(get_finders())
-        print("Loading textures:")
-        for name, texture in self.textures.items():
-            for finder in finders:
-                path = finder.find(name)
-                if path:
-                    print(" - {}".format(path))
-                    image = Image.open(path)
-                    texture.set_image(image)
-                    break
-            else:
-                raise ImproperlyConfigured("Cannot find texture {}".format(name))
-
-        self._on_loaded()
+        found_path = self._find_last_of(meta.path, list(get_finders()))
+
+        if not found_path:
+            raise ImproperlyConfigured("Cannot find texture {}".format(meta.path))
+
+        print("Loading: {}".format(meta.path))
+        texture = meta.cls(path=meta.path, **meta.kwargs)
+        image = Image.open(found_path)
+        texture.set_image(image)
+        self.file_map[meta.path] = texture
+
+        return texture
+
+    def _destroy(self, obj):
+        obj.release()
 
 
 textures = Textures()

demosys/resources/tracks.py

@@ -25,11 +25,11 @@ def get(self, name) -> Track:
             self.track_map[name] = track
         return track
 
-    def load(self):
-        """
-        Dummy. This will be handled by the rocket library,
-        """
-        pass
+    # def load(self):
+    #     """
+    #     Dummy. This will be handled by the rocket library,
+    #     """
+    #     pass
 
 
 tracks = Tracks()

demosys/scene/scene.py

@@ -30,7 +30,7 @@ def __init__(self, name, mesh_shaders=None, **kwargs):
         self.diagonal_size = 1.0
 
         self.bbox_vao = geometry.bbox()
-        self.bbox_shader = shaders.get('scene_default/bbox.glsl')
+        self.bbox_shader = shaders.load('scene_default/bbox.glsl')
 
         self._view_matrix = matrix44.create_identity()
 

demosys/scene/shaders.py

@@ -41,7 +41,7 @@ class ColorShader(MeshShader):
     Simple color shader
     """
     def __init__(self, shader=None, **kwargs):
-        super().__init__(shader=shaders.get("scene_default/color.glsl", create=True))
+        super().__init__(shader=shaders.load("scene_default/color.glsl"))
 
     def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
 
@@ -79,7 +79,7 @@ class TextureShader(MeshShader):
     Simple texture shader
     """
     def __init__(self, shader=None, **kwargs):
-        super().__init__(shader=shaders.get("scene_default/texture.glsl", create=True))
+        super().__init__(shader=shaders.load("scene_default/texture.glsl"))
 
     def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
         # if mesh.material.double_sided:
@@ -112,7 +112,7 @@ class FallbackShader(MeshShader):
     Fallback shader only rendering positions in white
     """
     def __init__(self, shader=None, **kwargs):
-        super().__init__(shader=shaders.get("scene_default/fallback.glsl", create=True))
+        super().__init__(shader=shaders.load("scene_default/fallback.glsl"))
 
     def draw(self, mesh, projection_matrix=None, view_matrix=None, camera_matrix=None, time=0):
 

tests/resources/textures/crate.jpg

@@ -56,15 +56,50 @@ def test_scene(self):
         with self.assertRaises(ImproperlyConfigured):
             resources.scenes.load('notfound.gltf')
 
-    # def test_shaders(self):
-    #     result = resources.shaders.get('vf_pos.glsl')
-    #     resources.shaders.load()
-    #     self.assertNotEqual(result.mglo, None)
-
-    # def test_textures(self):
-    #     result = resources.textures.get('wood.jpg')
-    #     resources.textures.load()
-    #     self.assertNotEqual(result.mglo, None)
+    def test_shaders(self):
+        resources.shaders.flush(destroy=True)
+        shader1 = resources.shaders.load('vf_pos.glsl')
+        shader2 = resources.shaders.load('vgf_quads.glsl')
+        self.assertEqual(resources.shaders.count, 2)
+
+        # Attempt to reload shaders
+        resources.shaders.reload()
+        self.assertEqual(resources.shaders.count, 2)
+
+        # Ensure requesting the same file returns the existing one
+        shader = resources.shaders.load('vf_pos.glsl')
+        self.assertEqual(shader, shader1)
+        shader = resources.shaders.load('vgf_quads.glsl')
+        self.assertEqual(shader, shader2)
+
+        # Delete and destroy
+        resources.shaders.delete(shader1, destroy=True)
+        self.assertEqual(resources.shaders.count, 1)
+        resources.shaders.flush(destroy=True)
+        self.assertEqual(resources.shaders.count, 0)
+
+        with self.assertRaises(ImproperlyConfigured):
+            resources.shaders.load('notfound.glsl')
+
+    def test_textures(self):
+        texture1 = resources.textures.load('wood.jpg')
+        texture2 = resources.textures.load('crate.jpg')
+        self.assertEqual(resources.textures.count, 2)
+
+        # Ensure requesting the same file returns the existing one
+        texture = resources.textures.load('wood.jpg')
+        self.assertEqual(texture, texture1)
+        texture = resources.textures.load('crate.jpg')
+        self.assertEqual(texture, texture2)
+
+        # Delete and destroy
+        resources.textures.delete(texture1, destroy=True)
+        self.assertEqual(resources.textures.count, 1)
+        resources.textures.flush(destroy=True)
+        self.assertEqual(resources.textures.count, 0)
+
+        with self.assertRaises(ImproperlyConfigured):
+            resources.textures.load('notfound.png')
 
     # def test_resource_override(self):
     #     pass