Scene files rewrite

Author: einarf

demosys/opengl/vao.py

@@ -239,6 +239,17 @@ def _create_vao_instance(self, shader):
 
         return vao
 
+    def release(self):
+        """Destroy the vao object and its buffers"""
+        for key, vao in self.vaos:
+            vao.release()
+
+        for buff in self.buffers:
+            buff.buffer.release()
+
+        if self._index_buffer:
+            self._index_buffer.release()
+
 
 class VAOError(Exception):
     pass

demosys/resources/scenes.py

@@ -11,20 +11,26 @@
 from .base import BaseRegistry
 
 
+class SceneMeta:
+
+    def __init__(self, path, loader_cls, **kwargs):
+        self.path = path
+        self.loader_cls = loader_cls
+        self.kwargs = kwargs
+
+
 class Scenes(BaseRegistry):
     """
     A registry for scense requested by effects.
     Once all effects are initialized, we ask this class to load the scenes.
     """
     def __init__(self):
         super().__init__()
-        self.scenes = {}
-
-    @property
-    def count(self):
-        return len(self.scenes)
+        self.scene_loaders = [
+            import_string(loader) for loader in settings.SCENE_LOADERS
+        ]
 
-    def get(self, path: Union[str, Path], **kwargs) -> Scene:
+    def load(self, path: Union[str, Path], **kwargs) -> Scene:
         """
         Get or create a scene object.
         This may return an empty object that will be filled during load
@@ -36,33 +42,46 @@ def get(self, path: Union[str, Path], **kwargs) -> Scene:
         """
         path = Path(path)
 
+        scene = self.file_map.get(path)
+        if scene:
+            return scene
+
+        meta = self.load_deferred(path, **kwargs)
+        scene = self._load(meta)
+
+        return scene
+
+    def load_deferred(self, path: Union[str, Path], **kwargs) -> SceneMeta:
         # Figure out what scene loader class should be used
-        for loader_name in settings.SCENE_LOADERS:
-            loader_cls = import_string(loader_name)
+        for loader_cls in self.scene_loaders:
             if loader_cls.supports_file(path):
-                if path not in self.scenes:
-                    loader_cls = import_string(loader_name)
-                    self.scenes[path] = Scene(path, loader=loader_cls(path), **kwargs)
                 break
         else:
-            raise ImproperlyConfigured("Scene {} has no loader class registered. Check settings.SCENE_LOADERS")
-
-        return self.scenes[path]
-
-    def load(self):
-        finders = list(get_finders())
-        print("Loading scenes:")
-        for name, scene in self.scenes.items():
-            for finder in finders:
-                path = finder.find(name)
-                if path:
-                    print(" - {}".format(path))
-                    scene.load(path)
-                    break
-            else:
-                raise ImproperlyConfigured("Cannot find scene {}".format(name))
-
-        self._on_loaded()
+            raise ImproperlyConfigured(
+                "Scene {} has no loader class registered. Check settings.SCENE_LOADERS".format(path))
+
+        meta = SceneMeta(path, loader_cls, **kwargs)
+
+        self.file_meta[path] = meta
+        self.file_map[path] = None
+
+        return meta
+
+    def _load(self, meta) -> Scene:
+        found_path = self._find_last_of(meta.path, list(get_finders()))
+
+        if not found_path:
+            raise ImproperlyConfigured("Cannot find scene file {}".format(meta.path))
+
+        print("Loading: {}".format(meta.path))
+        scene = Scene(meta.path, loader=meta.loader_cls(meta.path), **meta.kwargs)
+        scene.load(found_path)
+
+        self.file_map[meta.path] = scene
+        return scene
+
+    def _destroy(self, obj):
+        obj.destroy()
 
 
 scenes = Scenes()

tests/test_resources.py

@@ -1,9 +1,70 @@
 from demosys.test import DemosysTestCase
 from demosys import resources
+from demosys.core.exceptions import ImproperlyConfigured
 
 
 class ResourceTestCase(DemosysTestCase):
 
-    def test_stuff(self):
-        result = resources.shaders.get('vf_pos.glsl', create=True)
-        resources.shaders.load()
+    def test_datafiles(self):
+        """Loading data files"""
+        # string and binary data file
+        data_str = resources.data.load('data.txt', mode="text")
+        data_bin = resources.data.load('data.bin', mode="binary")
+        self.assertEqual(data_str.data, '1234')
+        self.assertEqual(data_bin.data, b'\x01\x02\x03\x04')
+
+        # Ensure requesting the same file returns the existing one
+        data = resources.data.load('data.txt', mode="text")
+        self.assertEqual(data, data_str)
+        data = resources.data.load('data.bin', mode="binary")
+        self.assertEqual(data, data_bin)
+        self.assertEqual(resources.data.count, 2)
+
+        # Delete and destroy
+        resources.data.delete(data_str, destroy=True)
+        self.assertIsNone(data_str.data)
+        self.assertEqual(resources.data.count, 1)
+        resources.data.flush(destroy=True)
+        self.assertEqual(resources.data.count, 0)
+
+        with self.assertRaises(ImproperlyConfigured):
+            resources.data.load('notfound.bin')
+
+    def test_scene(self):
+        scene_obj = resources.scenes.load('cube.obj')
+        self.assertEqual(len(scene_obj.nodes), 0)
+        self.assertEqual(len(scene_obj.root_nodes), 1)
+
+        scene_gltf = resources.scenes.load('BoxTextured/glTF/BoxTextured.gltf')
+        self.assertEqual(len(scene_gltf.nodes), 2)
+        self.assertEqual(len(scene_gltf.root_nodes), 1)
+
+        # Ensure requesting the same file returns the existing one
+        scene = resources.scenes.load('cube.obj')
+        self.assertEqual(scene, scene_obj)
+        scene = resources.scenes.load('BoxTextured/glTF/BoxTextured.gltf')
+        self.assertEqual(scene, scene_gltf)
+
+        self.assertEqual(resources.scenes.count, 2)
+
+        # Delete and destroy
+        resources.scenes.delete(scene_obj, destroy=True)
+        self.assertEqual(resources.scenes.count, 1)
+        resources.scenes.flush(destroy=True)
+        self.assertEqual(resources.scenes.count, 0)
+
+        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_resource_override(self):
+    #     pass