refactor: add material nodegroup back

multi_user/bl_types/bl_curve.py

@@ -21,7 +21,7 @@ import bpy.types as T
 import mathutils
 import logging
 
-from .. import utils
+from ..utils import get_preferences
 from replication.protocol import ReplicatedDatablock
 from .dump_anything import (Dumper, Loader,
                             np_load_collection,
@@ -255,7 +255,7 @@ class BlCurve(ReplicatedDatablock):
         for material in datablock.materials:
             if material:
                 deps.append(material)
-        
+
         deps.extend(resolve_animation_dependencies(datablock))
 
         return deps
@@ -263,7 +263,7 @@ class BlCurve(ReplicatedDatablock):
     @staticmethod
     def diff(self):
         if 'EDIT' in bpy.context.mode \
-                and not self.preferences.sync_flags.sync_during_editmode:
+                and not get_preferences().sync_flags.sync_during_editmode:
             return None
         else:
             return super().diff()

multi_user/bl_types/bl_file.py

@@ -27,6 +27,7 @@ from replication.constants import DIFF_BINARY, UP
 from replication.protocol import ReplicatedDatablock
 
 from .. import utils
+from ..utils import get_preferences
 from .dump_anything import Dumper, Loader
 
 
@@ -64,8 +65,7 @@ class BlFile(ReplicatedDatablock):
         
         if self.instance and not self.instance.exists():
             raise FileNotFoundError(str(self.instance))
-   
-        self.preferences = utils.get_preferences()
+
 
     def resolve(self, construct = True):
         self.instance = Path(get_filepath(self.data['name']))
@@ -81,7 +81,7 @@ class BlFile(ReplicatedDatablock):
     def push(self, socket, identity=None, check_data=False):
         super().push(socket, identity=None, check_data=False)
         
-        if self.preferences.clear_memory_filecache:
+        if get_preferences().clear_memory_filecache:
                 del self.data['file']
 
     def _dump(self, instance=None):
@@ -123,7 +123,7 @@ class BlFile(ReplicatedDatablock):
             file = open(target, "wb")
             file.write(data['file'])
             
-            if self.preferences.clear_memory_filecache:
+            if get_preferences().clear_memory_filecache:
                 del self.data['file']
         except IOError:
             logging.warning(f"{target} doesn't exist, skipping")
@@ -131,7 +131,7 @@ class BlFile(ReplicatedDatablock):
             file.close()
 
     def diff(self):
-        if self.preferences.clear_memory_filecache:
+        if get_preferences().clear_memory_filecache:
             return False
         else:
             if not self.instance:

multi_user/bl_types/bl_gpencil.py

@@ -313,7 +313,7 @@ class BlGpencil(ReplicatedDatablock):
                 or self.layer_changed() \
                 or self.frame_changed() \
                 or bpy.context.mode == 'OBJECT' \
-                or self.preferences.sync_flags.sync_during_editmode:
+                or get_preferences().sync_flags.sync_during_editmode:
             return super().diff()
         else:
             return None

multi_user/bl_types/bl_material.py

@@ -26,7 +26,8 @@ from uuid import uuid4
 from .dump_anything import Loader, Dumper
 from replication.protocol import ReplicatedDatablock
 
-from .bl_datablock import get_datablock_from_uuid
+from .bl_datablock import get_datablock_from_uuid, resolve_datablock_from_uuid
+from .bl_action import dump_animation_data, load_animation_data, resolve_animation_dependencies
 
 NODE_SOCKET_INDEX = re.compile('\[(\d*)\]')
 IGNORED_SOCKETS = ['GEOMETRY', 'SHADER', 'CUSTOM']
@@ -398,29 +399,33 @@ class BlMaterial(ReplicatedDatablock):
     bl_icon = 'MATERIAL_DATA'
     bl_reload_parent = False
 
+    @staticmethod
     def construct(data: dict) -> object:
         return bpy.data.materials.new(data["name"])
 
+    @staticmethod
     def load(data: dict, datablock: object):
+        load_animation_data(datablock.get('animation_data'), datablock)
+
         loader = Loader()
 
         is_grease_pencil = data.get('is_grease_pencil')
         use_nodes = data.get('use_nodes')
 
-        loader.load(target, data)
+        loader.load(datablock, data)
 
         if is_grease_pencil:
-            if not target.is_grease_pencil:
-                bpy.data.materials.create_gpencil_data(target)
-            loader.load(target.grease_pencil, data['grease_pencil'])
+            if not datablock.is_grease_pencil:
+                bpy.data.materials.create_gpencil_data(datablock)
+            loader.load(datablock.grease_pencil, data['grease_pencil'])
         elif use_nodes:
-            if target.node_tree is None:
-                target.use_nodes = True
+            if datablock.node_tree is None:
+                datablock.use_nodes = True
 
-            load_node_tree(data['node_tree'], target.node_tree)
+            load_node_tree(data['node_tree'], datablock.node_tree)
 
+    @staticmethod
     def dump(datablock: object) -> dict:
-        assert(instance)
         mat_dumper = Dumper()
         mat_dumper.depth = 2
         mat_dumper.include_filter = [
@@ -446,9 +451,9 @@ class BlMaterial(ReplicatedDatablock):
             'line_priority',
             'is_grease_pencil'
         ]
-        data = mat_dumper.dump(instance)
+        data = mat_dumper.dump(datablock)
 
-        if instance.is_grease_pencil:
+        if datablock.is_grease_pencil:
             gp_mat_dumper = Dumper()
             gp_mat_dumper.depth = 3
 
@@ -482,19 +487,35 @@ class BlMaterial(ReplicatedDatablock):
                 'use_overlap_strokes',
                 'use_fill_holdout',
             ]
-            data['grease_pencil'] = gp_mat_dumper.dump(instance.grease_pencil)
-        elif instance.use_nodes:
-            data['node_tree'] = dump_node_tree(instance.node_tree)
+            data['grease_pencil'] = gp_mat_dumper.dump(datablock.grease_pencil)
+        elif datablock.use_nodes:
+            data['node_tree'] = dump_node_tree(datablock.node_tree)
 
+        data['animation_data'] = dump_animation_data(datablock)
         return data
 
+    @staticmethod
+    def resolve(data: dict) -> object:
+        uuid = data.get('uuid')
+        name = data.get('name')
+        datablock = resolve_datablock_from_uuid(uuid, bpy.data.materials)
+        if datablock is None:
+            datablock = bpy.data.materials.get(name)
+
+        return datablock
+
+
+    @staticmethod
     def resolve_deps(datablock: object) -> [object]:
         # TODO: resolve node group deps
         deps = []
 
-        if self.instance.use_nodes:
-            deps.extend(get_node_tree_dependencies(self.instance.node_tree))
-        if self.is_library:
-            deps.append(self.instance.library)
+        if datablock.use_nodes:
+            deps.extend(get_node_tree_dependencies(datablock.node_tree))
+
+        deps.extend(resolve_animation_dependencies(datablock))
 
         return deps
+
+_type = bpy.types.Material
+_class = BlMaterial

multi_user/bl_types/bl_metaball.py

@@ -24,6 +24,8 @@ from .dump_anything import (
     np_dump_collection, np_load_collection)
 
 from replication.protocol import ReplicatedDatablock
+from .bl_datablock import resolve_datablock_from_uuid
+from .bl_action import dump_animation_data, load_animation_data, resolve_animation_dependencies
 
 
 ELEMENT = [
@@ -69,22 +71,26 @@ class BlMetaball(ReplicatedDatablock):
     bl_icon = 'META_BALL'
     bl_reload_parent = False
 
+    @staticmethod
     def construct(data: dict) -> object:
         return bpy.data.metaballs.new(data["name"])
 
+    @staticmethod
     def load(data: dict, datablock: object):
-        loader = Loader()
-        loader.load(target, data)
+        load_animation_data(datablock.get('animation_data'), datablock)
 
-        target.elements.clear()
+        loader = Loader()
+        loader.load(datablock, data)
+
+        datablock.elements.clear()
 
         for mtype in data["elements"]['type']:
-            new_element = target.elements.new()
+            new_element = datablock.elements.new()
 
-        load_metaball_elements(data['elements'], target.elements)
+        load_metaball_elements(data['elements'], datablock.elements)
 
+    @staticmethod
     def dump(datablock: object) -> dict:
-        assert(instance)
         dumper = Dumper()
         dumper.depth = 1
         dumper.include_filter = [
@@ -98,7 +104,29 @@ class BlMetaball(ReplicatedDatablock):
             'texspace_size'
         ]
 
-        data = dumper.dump(instance)
-        data['elements'] = dump_metaball_elements(instance.elements)
+        data = dumper.dump(datablock)
+        data['animation_data'] = dump_animation_data(datablock)
+        data['elements'] = dump_metaball_elements(datablock.elements)
 
         return data
+
+    @staticmethod
+    def resolve(data: dict) -> object:
+        uuid = data.get('uuid')
+        name = data.get('name')
+        datablock = resolve_datablock_from_uuid(uuid, bpy.data.metaballs)
+        if datablock is None:
+            datablock = bpy.data.metaballs.get(name)
+
+        return datablock
+
+    @staticmethod
+    def resolve_deps(datablock: object) -> [object]:
+        deps = []
+
+        deps.extend(resolve_animation_dependencies(datablock))
+
+        return deps
+
+_type = bpy.types.MetaBall
+_class = BlMetaball

multi_user/bl_types/bl_node_group.py

@@ -24,6 +24,8 @@ from replication.protocol import ReplicatedDatablock
 from .bl_material import (dump_node_tree,
                           load_node_tree,
                           get_node_tree_dependencies)
+from .bl_datablock import resolve_datablock_from_uuid
+from .bl_action import dump_animation_data, load_animation_data, resolve_animation_dependencies
 
 class BlNodeGroup(ReplicatedDatablock):
     bl_id = "node_groups"
@@ -32,14 +34,34 @@ class BlNodeGroup(ReplicatedDatablock):
     bl_icon = 'NODETREE'
     bl_reload_parent = False
 
+    @staticmethod
     def construct(data: dict) -> object:
         return bpy.data.node_groups.new(data["name"], data["type"])
 
+    @staticmethod
     def load(data: dict, datablock: object):
-        load_node_tree(data, target)
+        load_node_tree(data, datablock)
 
+    @staticmethod
     def dump(datablock: object) -> dict:
-        return dump_node_tree(instance)
+        return dump_node_tree(datablock)
 
+    @staticmethod
+    def resolve(data: dict) -> object:
+        uuid = data.get('uuid')
+        name = data.get('name')
+        datablock = resolve_datablock_from_uuid(uuid, bpy.data.node_groups)
+        if datablock is None:
+            datablock = bpy.data.node_groups.get(name)
+
+        return datablock
+
+    @staticmethod
     def resolve_deps(datablock: object) -> [object]:
-        return get_node_tree_dependencies(self.instance)
+        deps = []
+        deps.extend(get_node_tree_dependencies(datablock))
+        deps.extend(resolve_animation_dependencies(datablock))
+        return deps
+
+_type = [bpy.types.ShaderNodeTree, bpy.types.GeometryNodeTree]
+_class = BlNodeGroup

multi_user/bl_types/bl_object.py

@@ -25,6 +25,7 @@ from replication.exception import ContextError
 from replication.protocol import ReplicatedDatablock
 from .bl_datablock import get_datablock_from_uuid, resolve_datablock_from_uuid
 from .bl_material import IGNORED_SOCKETS
+from ..utils import get_preferences
 from .bl_action import dump_animation_data, load_animation_data, resolve_animation_dependencies
 from .dump_anything import (
     Dumper,
@@ -577,7 +578,7 @@ class BlObject(ReplicatedDatablock):
     @staticmethod
     def dump(datablock: object) -> dict:
         if _is_editmode(datablock):
-            if self.preferences.sync_flags.sync_during_editmode:
+            if get_preferences().sync_flags.sync_during_editmode:
                 datablock.update_from_editmode()
             else:
                 raise ContextError("Object is in edit-mode.")