fix: material and world diff function

bl_types/__init__.py

@@ -12,7 +12,8 @@ __all__ = [
     'bl_material',
     'bl_library',
     'bl_armature',
-    'bl_action'
+    'bl_action',
+    'bl_world'
 ]  # Order here defines execution order
 
 from . import *

bl_types/bl_material.py

@@ -68,12 +68,21 @@ class BlMaterial(BlDatablock):
 
     def dump(self, pointer=None):
         assert(pointer)
-
-        data = utils.dump_datablock(pointer, 2)
+        mat_dumper = utils.dump_anything.Dumper()
+        mat_dumper.depth = 2
+        mat_dumper.exclude_filter = [
+            "preview",
+            "original",
+            "uuid",
+            "users",
+            "alpha_threshold",
+            "line_color"
+        ]
+        data = mat_dumper.dump(pointer)
         if pointer.use_nodes:
             nodes = {}
             dumper = utils.dump_anything.Dumper()
-            dumper.depth = 2
+            dumper.depth = 1
             dumper.exclude_filter = [
                 "dimensions",
                 "select",
@@ -87,6 +96,7 @@ class BlMaterial(BlDatablock):
                 "show_tetxures",
                 "show_preview",
                 "outputs",
+                "view_center",
             ]
 
             for node in pointer.node_tree.nodes:
@@ -114,8 +124,9 @@ class BlMaterial(BlDatablock):
 
     def diff(self):
         diff_rev = diff(self.dump(pointer=self.pointer), self.buffer)
+        print(diff_rev)
         return (self.bl_diff() or
-                len(diff_rev.keys()) > 1)
+                len(diff_rev.keys()) > 0)
 
     def resolve_dependencies(self):
         deps = []

bl_types/bl_scene.py

@@ -58,12 +58,18 @@ class BlScene(BlDatablock):
 
     def resolve_dependencies(self):
         deps = []
-        
+
+        # child collections
         for child in self.pointer.collection.children:
             deps.append(child)
+        
+        # childs objects
         for object in self.pointer.objects:
             deps.append(object)
         
+        # world
+        deps.append(self.pointer.world)
+        
         return deps
     
     def is_valid(self):

bl_types/bl_world.py

@@ -0,0 +1,137 @@
+import bpy
+import mathutils
+from jsondiff import diff
+
+from .. import utils
+from .bl_datablock import BlDatablock
+
+
+class BlWorld(BlDatablock):
+    def construct(self, data):
+        return bpy.data.worlds.new(data["name"])
+
+    def load(self, data, target):
+        if data["use_nodes"]:
+            if target.node_tree is None:
+                target.use_nodes = True
+
+            target.node_tree.nodes.clear()
+
+            for node in data["node_tree"]["nodes"]:
+                index = target.node_tree.nodes.find(node)
+
+                if index is -1:
+                    node_type = data["node_tree"]["nodes"][node]["bl_idname"]
+
+                    target.node_tree.nodes.new(type=node_type)
+
+                utils.dump_anything.load(
+                    target.node_tree.nodes[index], data["node_tree"]["nodes"][node])
+
+                if data["node_tree"]["nodes"][node]['type'] == 'TEX_IMAGE':
+                    target.node_tree.nodes[index].image = bpy.data.images[data["node_tree"]
+                                                                          ["nodes"][node]['image']['name']]
+
+                for input in data["node_tree"]["nodes"][node]["inputs"]:
+                    try:
+                        if hasattr(target.node_tree.nodes[index].inputs[input], "default_value"):
+                            target.node_tree.nodes[index].inputs[input].default_value = data[
+                                "node_tree"]["nodes"][node]["inputs"][input]["default_value"]
+                    except Exception as e:
+                        print("loading error {}".format(e))
+                        continue
+
+            # Load nodes links
+            target.node_tree.links.clear()
+
+            for link in data["node_tree"]["links"]:
+                current_link = data["node_tree"]["links"][link]
+                input_socket = target.node_tree.nodes[current_link['to_node']
+                                                      ['name']].inputs[current_link['to_socket']['name']]
+                output_socket = target.node_tree.nodes[current_link['from_node']
+                                                       ['name']].outputs[current_link['from_socket']['name']]
+
+                target.node_tree.links.new(input_socket, output_socket)
+
+    def dump(self, pointer=None):
+        assert(pointer)
+
+        world_dumper = utils.dump_anything.Dumper()
+        world_dumper.depth = 2
+        world_dumper.exclude_filter = [
+            "preview",
+            "original",
+            "uuid"
+        ] 
+        data = world_dumper.dump(pointer)
+        if pointer.use_nodes:
+            nodes = {}
+            dumper = utils.dump_anything.Dumper()
+            dumper.depth = 2
+            dumper.exclude_filter = [
+                "dimensions",
+                "select",
+                "bl_height_min",
+                "bl_height_max",
+                "bl_width_min",
+                "bl_width_max",
+                "bl_width_default",
+                "hide",
+                "show_options",
+                "show_tetxures",
+                "show_preview",
+                "outputs",
+                "preview",
+                "original",
+                "width_hidden"
+            ]
+
+            for node in pointer.node_tree.nodes:
+                nodes[node.name] = dumper.dump(node)
+
+                if hasattr(node,'inputs'):
+                    nodes[node.name]['inputs'] = {}
+
+                    for i in node.inputs:
+                        input_dumper = utils.dump_anything.Dumper()
+                        input_dumper.depth = 2
+                        input_dumper.include_filter = ["default_value"]
+                        if hasattr(i,'default_value'):
+                            nodes[node.name]['inputs'][i.name] = input_dumper.dump(i) 
+            data["node_tree"]['nodes'] = nodes
+            utils.dump_datablock_attibutes(
+                pointer.node_tree, ["links"], 3, data['node_tree'])
+        return data
+
+    def resolve(self):
+        assert(self.buffer)
+        self.pointer = bpy.data.worlds.get(self.buffer['name'])
+
+    def diff(self):
+        diff_rev = diff(self.dump(pointer=self.pointer), self.buffer)
+        return (self.bl_diff() or
+                len(diff_rev.keys()) > 0)
+
+    def resolve_dependencies(self):
+        deps = []
+
+        if self.pointer.use_nodes:
+            for node in self.pointer.node_tree.nodes:
+                if node.type == 'TEX_IMAGE':
+                    deps.append(node.image)
+        if self.is_library:
+            deps.append(self.pointer.library)
+
+        return deps
+
+    def is_valid(self):
+        return bpy.data.worlds.get(self.buffer['name'])
+
+
+bl_id = "worlds"
+bl_class = bpy.types.World
+bl_rep_class = BlWorld
+bl_delay_refresh = 4
+bl_delay_apply = 4
+bl_automatic_push = True
+bl_icon = 'WORLD_DATA'

libs/dump_anything.py

@@ -160,6 +160,9 @@ class Dumper:
         all_property_names = [p for p in dir(default) if is_valid_property(p) and p != '']
         dump = {}
         for p in all_property_names:
+            if (self.exclude_filter and p in self.exclude_filter) or\
+                (self.include_filter and p not in self.include_filter):
+                return False
             dp = self._dump_any(getattr(default, p), depth)
             if not (dp is None):
                 dump[p] = dp