import bpy import mathutils from pprint import pprint import json import itertools from copy import copy from os.path import abspath def get_default(prop): """Get the default value of a bl property""" if getattr(prop, 'is_array', False): return list(prop.default_array) elif hasattr(prop, 'default'): return prop.default def get_dumper(bl_object, fallback=None): """Find the right dumper type by checking inheritance""" for dp in dumpers: if isinstance(bl_object, dp.bl_type): return dp return fallback or Dumper def get_bl_object(data): """Find the bl object for loading data into it depending on the type and the context""" if data.get('_new', {}).get('type') == 'GeometryNodeTree': return bpy.context.object.modifiers.active.node_group def dump(ob): """Generic Recursive Dump, convert any object into a dict""" Dumper.pointers.clear() if isinstance(ob, (list, tuple)): data = [get_dumper(o).dump(o) for o in ob] else: data = get_dumper(ob).dump(ob) Dumper.pointers.clear() return data def load(data, bl_object=None): """Generic Load to create an object from a dict""" Dumper.pointers.clear() #print(Dumper.pointers) if bl_object is None: bl_object = get_bl_object(data) dumper = get_dumper(bl_object) dumper.load(data, bl_object) Dumper.pointers.clear() def set_attribute(bl_object, attr, value): try: setattr(bl_object, attr, value) except Exception as e: print(e) class Dumper: pointers = {} includes = [] excludes = ["rna_type", "bl_rna", 'id_data', 'depsgraph'] @classmethod def properties(cls, bl_object): if cls.includes and not cls.excludes: return [bl_object.bl_rna.properties[p] for p in cls.includes] else: return [ p for p in bl_object.bl_rna.properties if not p.identifier.startswith('bl_') and p.identifier not in cls.excludes] @classmethod def new(cls, data): print(f'New not implemented for data {data}') @classmethod def load(cls, data, bl_object=None): if bl_object is None: bl_object = cls.new(data) if bl_object is None: return #pprint(data) if bl_pointer := data.get('bl_pointer'): cls.pointers[bl_pointer] = bl_object props = cls.properties(bl_object) for key, value in sorted(data.items(), key=lambda x: props.index(x[0]) if x[0] in props else 0): if key.startswith('_') or key not in bl_object.bl_rna.properties: continue prop = bl_object.bl_rna.properties[key] attr = getattr(bl_object, key) if prop.type == 'COLLECTION': dumper = PropCollection if hasattr(attr, 'bl_rna'): bl_type = attr.bl_rna.type_recast() dumper = get_dumper(bl_type, fallback=PropCollection) dumper.load(value, attr) continue elif prop.type == 'POINTER': # if key == 'node_tree': # print('--------------') # print(bl_object, value) # print(cls.pointers) if isinstance(value, int): # It's a pointer if value not in cls.pointers: print(bl_object, "not loaded yet", prop) value = cls.pointers[value] elif value is None: set_attribute(bl_object, key, value) else: bl_type = prop.fixed_type.bl_rna.type_recast() dumper = get_dumper(bl_type) # If the pointer exist register the pointer then load data #print('-----', value) #pointer = if attr is None: attr = dumper.new(value) dumper.load(value, attr) #attr = getattr(bl_object, key) #if not attr: cls.pointers[value['bl_pointer']] = attr if hasattr(attr, 'update'): attr.update() value = attr if not prop.is_readonly: set_attribute(bl_object, key, value) # Some coll needs a manual update like curve mapping if hasattr(attr, 'update'): attr.update() elif not prop.is_readonly: #print(key, value) set_attribute(bl_object, key, value) continue #return bl_object @classmethod def dump(cls, bl_object): if isinstance(bl_object, (str, int, float, dict, list, type(None))): return bl_object #print('Dumping object', bl_object) data = {"bl_pointer": bl_object.as_pointer()} cls.pointers[bl_object.as_pointer()] = bl_object for prop in cls.properties(bl_object): if not hasattr(bl_object, prop.identifier): print(f'{bl_object} has no attribute {prop.identifier}') continue #print(prop.identifier) value = getattr(bl_object, prop.identifier) # Not storing default value if prop.identifier not in cls.includes: if (array := getattr(prop, 'default_array', None)) and value == array: continue if isinstance(value, (str, int, float)) and value == prop.default: continue if getattr(prop, "is_array", False): value = PropArray.dump(value) elif prop.type == 'COLLECTION': value = PropCollection.dump(value) elif prop.type == 'POINTER' and value: #if prop.identifier == 'image': # print(bl_object, cls.pointers) if value.as_pointer() in cls.pointers: value = value.as_pointer() else: # print('Register Pointer', value.as_pointer(), value) cls.pointers[value.as_pointer()] = value # print(cls.pointers) # print() dumper = get_dumper(value) value = dumper.dump(value) elif bl_object.is_property_readonly(prop.identifier): continue else: dumper = get_dumper(value) value = dumper.dump(value) data[prop.identifier] = value return data class PropCollection(Dumper): bl_type = bpy.types.bpy_prop_collection @classmethod def dump(cls, coll): if not len(coll): return [] dumper = get_dumper(coll[0]) values = [dumper.dump(e) for e in coll] # Value cannot be None return [v for v in values if v is not None] @classmethod def load(cls, values, coll): if not values: return dumper = None if not hasattr(coll, 'new'): # Static collection for item, value in zip(coll, values): dumper = dumper or get_dumper(item) dumper.load(value, item) return new_func = coll.bl_rna.functions['new'] for i, value in enumerate(values): if value.get('_new'): params = value['_new'] else: params = {k: value.get(k, get_default(v)) for k, v in new_func.parameters.items()[:-1]} # Replace arg pointer with bl object valid_pointers = True for param in coll.bl_rna.functions['new'].parameters: if param.identifier not in params or param.type != 'POINTER': continue pointer_id = params[param.identifier] if bl_object := cls.pointers.get(pointer_id): params[param.identifier] = bl_object else: print(f'No Pointer found for param {param.identifier} of {coll}') valid_pointers = False if not valid_pointers: continue #print(param.identifier, cls.pointers[pointer_id]) try: item = coll.new(**params) except RuntimeError as e: #print(e, coll.data) #print() try: item = coll[i] except IndexError as e: #print(e, coll.data) break dumper = get_dumper(item) dumper.load(value, item)#(item, value) class PropArray(Dumper): bl_type = bpy.types.bpy_prop_array @classmethod def dump(cls, array): flat_array = [] for item in array: if isinstance(item, (int, float)): flat_array.append(item) else: flat_array.extend(cls.dump(item)) return flat_array class NodeSocket(Dumper): bl_type = bpy.types.NodeSocket excludes = Dumper.excludes + ["node", "links", "display_shape", "rna_type", "link_limit"] @classmethod def dump(cls, socket): if socket.is_unavailable: return None #cls.pointers[socket.as_pointer()] = socket data = super().dump(socket) #data["_id"] = socket.as_pointer() #data.pop('name', '') return data class NodeGeometryRepeatOutputItems(PropCollection): bl_type = bpy.types.NodeGeometryRepeatOutputItems @classmethod def load(cls, values, coll): coll.clear() super().load(values, coll) class NodeLink(Dumper): bl_type = bpy.types.NodeLink @classmethod def dump(cls, link): return {"_new": { "input": link.from_socket.as_pointer(), "output": link.to_socket.as_pointer() } } class NodeTreeInterfaceSocket(Dumper): bl_type = bpy.types.NodeTreeInterfaceSocket excludes = Dumper.excludes + ["parent", "interface_items"] @classmethod def dump(cls, socket): #cls.pointers[socket.as_pointer()] = socket data = super().dump(socket) #data["_id"] = socket.as_pointer() data['_new'] = {"name": data.get('name', '')} if socket.item_type == 'SOCKET': data['_new']["in_out"] = socket.in_out # It's a real panel not the interface root if socket.parent.parent: data['parent'] = socket.parent.as_pointer() return data class NodeSockets(PropCollection): @classmethod def load(cls, values, coll): #return node_sockets = [s for s in coll if not s.is_unavailable] for socket, value in zip(node_sockets, values): cls.pointers[value['bl_pointer']] = socket Dumper.load(value, socket) # for k, v in value.items(): # if k not in socket.bl_rna.properties: # continue # setattr(socket, k, v) """ # Match Inputs Pointers node_sockets = [s for s in coll if not s.is_unavailable] if len(node_sockets) == len(inputs): # Match by index super().load({"inputs": inputs}, node) for socket, value in zip(node_sockets, coll): cls.pointers[value['_id']] = socket else: # Match by name print(f'Match Inputs by Name for node {node}') for socket in node_sockets: index = next((i for i, v in enumerate(inputs) if v['name'] == socket.name), None) if index is None: continue value = inputs[index] print(socket, value) cls.pointers[value['_id']] = socket Dumper.load(value, socket) del inputs[index] """ class NodeInputs(NodeSockets): bl_type = bpy.types.NodeInputs class NodeOutputs(NodeSockets): bl_type = bpy.types.NodeOutputs class Node(Dumper): bl_type = bpy.types.Node excludes = Dumper.excludes + ["dimensions", "height", "internal_links", "paired_output"] @classmethod def dump(cls, node=None): #cls.pointers[node.as_pointer()] = node data = super().dump(node) #data["_id"] = node.as_pointer() data["_new"] = {"type": node.bl_rna.identifier} # 'node_tree': node.id_data.as_pointer() if paired_output := getattr(node, "paired_output", None): data["_pair_with_output"] = paired_output.as_pointer() #if node.parent: # data['location'] -= Vector()node.parent.location return data @classmethod def load(cls, data, node): if node is None: return #cls.pointers[data['bl_pointer']] = node inputs = copy(data.pop('inputs', [])) outputs = copy(data.pop('outputs', [])) super().load(data, node) data['inputs'] = inputs data['outputs'] = outputs # Loading input and outputs after the properties super().load({"inputs": inputs, "outputs": outputs}, node) if node.parent: node.location += node.parent.location #if node.type != 'FRAME': # node.location.y -= 500 class CompositorNodeGlare(Node): bl_type = bpy.types.CompositorNodeGlare includes = ["quality"] class NodeTreeInterface(Dumper): bl_type = bpy.types.NodeTreeInterface @classmethod def load(cls, data, interface): print('Load Interface') for value in data.get('items_tree', []): item_type = value.get('item_type', 'SOCKET') if item_type == 'SOCKET': item = interface.new_socket(**value['_new']) elif item_type == 'PANEL': #print(value['_new']) item = interface.new_panel(**value['_new']) NodeTreeInterfaceSocket.load(value, item) interface.active_index = data.get('active_index', 0) class Nodes(PropCollection): bl_type = bpy.types.Nodes @classmethod def load(cls, values, coll): super().load(values, coll) # Pair zone input and output for node_data in values: if paired_output_id := node_data.get('_pair_with_output', None): node = cls.pointers[node_data['bl_pointer']] node.pair_with_output(cls.pointers[paired_output_id]) #print(node, node_data['outputs']) Dumper.load({"inputs": node_data['inputs'], "outputs": node_data['outputs']}, node) class NodeTree(Dumper): bl_type = bpy.types.NodeTree excludes = [] includes = ["name", "interface", "nodes", "links"] @classmethod def new(cls, data): if link := data.get('_link'): with bpy.data.libraries.load(link['filepath'], link=True) as (data_from, data_to): setattr(data_to, link['data_type'], [link['name']]) return getattr(data_to, link['data_type'])[0] return bpy.data.node_groups.new(**data["_new"]) @classmethod def dump(cls, node_tree): if node_tree.library: data = {'bl_pointer': node_tree.as_pointer()} filepath = abspath(bpy.path.abspath(node_tree.library.filepath, library=node_tree.library.library)) data["_link"] = {"filepath": filepath, "data_type": 'node_groups', 'name': node_tree.name} else: data = super().dump(node_tree) data["_new"] = {"type": node_tree.bl_rna.identifier, 'name': node_tree.name} return data class Points(PropCollection): @classmethod def load(cls, values, coll): new_func = coll.bl_rna.functions['new'] params = {k: get_default(v)+1.1 for k, v in new_func.parameters.items()[:-1]} # Match the same number of elements in collection if len(values) > len(coll): for _ in range(len(values) - len(coll)): coll.new(**params) for i, value in enumerate(values): Dumper.load(value, coll[i]) #for k, v in value.items(): #setattr(coll[i], k, v) class CurveMapPoints(Points): bl_type = bpy.types.CurveMapPoints class ColorRampElements(Points): bl_type = bpy.types.ColorRampElements class CompositorNodeOutputFileLayerSlots(PropCollection): bl_type = bpy.types.CompositorNodeOutputFileLayerSlots @classmethod def load(cls, values, coll): coll.clear() super().load(values, coll) class CompositorNodeOutputFileFileSlots(PropCollection): @classmethod def load(cls, values, coll): coll.clear() super().load(values, coll) class AOVs(PropCollection): bl_type = bpy.types.AOVs @classmethod def load(cls, values, coll): for value in values: aov = coll.get(value['name']) if not aov: aov = coll.add() Dumper.load(value, aov) class Image(Dumper): bl_type = bpy.types.Image excludes = [] includes = ['name', 'filepath'] @classmethod def new(cls, data): # image = next(( img for img in bpy.data.images if not img.library # and img.filepath == data['filepath']), None) # if image is None: # image = bpy.data.images.load(data['filepath']) return bpy.data.images.load(data['filepath'], check_existing=True) class Material(Dumper): bl_type = bpy.types.Material excludes = Dumper.excludes + ['preview', "original"] @classmethod def new(cls, data): material = bpy.data.materials.get(data.get('name', '')) if material is None: material = bpy.data.materials.new(data['name']) return material class Object(Dumper): bl_type = bpy.types.Object excludes = [] includes = ['name'] @classmethod def new(cls, data): if name := data.get('name'): return bpy.data.objects.get(name) class Scene(Dumper): bl_type = bpy.types.Scene excludes = [] includes = ['name'] @classmethod def new(cls, data): if scene := bpy.data.scenes.get(data.get('name', '')): return scene return bpy.data.scenes.new(name=data.get('name', '')) """ @classmethod def dump(cls, scene): view_layer = scene.view_layers[node.layer] view_layer_data = ViewLayer.dump(view_layer) return { 'bl_pointer': scene.as_pointer(), 'name': scene.name, 'render' : {'bl_pointer': scene.render.as_pointer(), "engine": scene.render.engine}, 'view_layers': [view_layer_data] } """ class Collection(Dumper): bl_type = bpy.types.Collection includes = ['name'] excludes = [] @classmethod def new(cls, data): if name := data.get('name'): return bpy.data.collections.get(name) # @classmethod # def dump(cls, data): # data = super().dump(data) # data['render'] = {"engine": scene.render.engine} # return data class CompositorNodeRLayers(Node): bl_type = bpy.types.CompositorNodeRLayers excludes = Dumper.excludes + ['scene'] @classmethod def load(cls, data, node): #print('load CompositorNodeRLayers') scene_data = data.pop('scene') #print(scene_data) layer = data.pop('layer') scene = Scene.new(scene_data) Scene.load(scene_data, scene) node.scene = scene node.layer = layer super().load(data, node) # Resetter the view_layer because it might have been created # with the scene attr in the dictionnary and nor available yet #print(bpy.) @classmethod def dump(cls, node): # Add scene and viewlayer passes data = super().dump(node) #if view_layer = node.scene.view_layers[node.layer] view_layer_data = ViewLayer.dump(view_layer) ''' view_layer_data = { "name": view_layer.name} properties = {p.name: p for p in view_layer.bl_rna.properties} for prop in view_layer.bl_rna: if prop.identifier.startswith('use_pass'): view_layer_data[prop.identifier] ''' #cls.pointers[bl_object.as_pointer()] = bl_object data['scene'] = { 'bl_pointer': node.scene.as_pointer(), 'name': node.scene.name, 'render' : {'bl_pointer': node.scene.render.as_pointer(), "engine": node.scene.render.engine}, 'view_layers': [view_layer_data] } return data class ViewLayer(Dumper): bl_type = bpy.types.ViewLayer excludes = Dumper.excludes + ['freestyle_settings', 'eevee', 'cycles', 'active_layer_collection', 'active_aov', 'active_lightgroup_index', 'active_lightgroup'] #includes = ['name'] class ViewLayers(PropCollection): bl_type = bpy.types.ViewLayers @classmethod def load(cls, values, coll): #print('LOAD VIEWLAYERS', values) for value in values: view_layer = coll.get(value['name']) if view_layer is None: view_layer = coll.new(value['name']) Dumper.load(value, view_layer) dumpers = [ CompositorNodeRLayers, CompositorNodeGlare, Node, NodeSocket, NodeTree, NodeLink, NodeTreeInterface, NodeTreeInterfaceSocket, NodeGeometryRepeatOutputItems, Image, Material, Object, Scene, Collection, ViewLayer, CurveMapPoints, ColorRampElements, NodeInputs, NodeOutputs, Nodes, ViewLayers, PropCollection, AOVs, PropArray, CompositorNodeOutputFileLayerSlots, CompositorNodeOutputFileFileSlots, ]