From 876511c4358352902ce777c203ebf05b557cf9a7 Mon Sep 17 00:00:00 2001 From: Jonas Holzman Date: Mon, 24 Mar 2025 15:49:27 +0100 Subject: [PATCH] Cleanup: Remove old Blender abstraction class files --- core/_node.py | 211 --------------------------------------------- core/_node_tree.py | 71 --------------- core/_sockets.py | 97 --------------------- 3 files changed, 379 deletions(-) delete mode 100644 core/_node.py delete mode 100644 core/_node_tree.py delete mode 100644 core/_sockets.py diff --git a/core/_node.py b/core/_node.py deleted file mode 100644 index c1a7c97..0000000 --- a/core/_node.py +++ /dev/null @@ -1,211 +0,0 @@ -import bpy -from mathutils import Color, Vector - -from .sockets import Input, Output - - -class Node: - """Blender Node abstraction.""" - - def __init__(self, bl_node, parent): - self.bl_node = bl_node - self.tree = parent - self.id = hex(id(self.bl_node)) - - self.data = {} - self.parameters = [] - - self._parent = None - self._scene = None - - for prop in self.bl_node.bl_rna.properties: - if prop.is_readonly: - continue - - prop_id = prop.identifier - - setattr(self, prop_id, getattr(self.bl_node, prop_id)) - self.parameters.append(prop_id) - - self.inputs = [Input(ipt, self.tree) for ipt in self.bl_node.inputs] - self.outputs = [Output(opt, self.tree) for opt in self.bl_node.outputs] - - @property - def parent(self): - """Get the Node from all the other nodes in the tree checking that the - parent of its blender node is the same as the blender node we are comparing. - - Returns: - Node: Node parent. - """ - - if self._parent: - return self._parent - - # if blender node doesn't have a parent - if not self.bl_node.parent: - self._parent = None - return self._parent - - for node in self.tree.nodes: - if node.bl_node == self.bl_node.parent: - self._parent = node - return self._parent - - @parent.setter - def parent(self, value): - """Set the Node parent, using the python object, it's id or the blender node. - - Args: - value (Node|str|bpy.types.Node): Node, id or blender node to set as parent. - """ - - # Node object case - if isinstance(value, Node): - self._parent = value - - # Node id case - elif isinstance(value, str) and value.startswith("0x"): - for node in self.tree.nodes: - if node.id == value: - self._parent = node - else: - print("Cannot find parent") - - # blender node case - elif isinstance(value, bpy.types.Node): - for node in self.tree.nodes: - if node.bl_node == value: - self._parent = node - - if self._parent: - self.bl_node.parent = self._parent.bl_node - - @classmethod - def from_blender_node(cls, bl_node, tree): - """Instanciate an abstract class based of the blender node idname. - - Args: - bl_node (bpy.types.Node): Blender Node To create abstraction from. - tree (NodeTree): Node tree object node belongs to. - - Returns: - Node: Node abstract according to the blender node type. - """ - if bl_node.bl_idname == "CompositorNodeRLayers": - return RenderLayersNode(bl_node, tree) - - elif bl_node.bl_idname == "CompositorNodeValToRGB": - return ColorRampNode(bl_node, tree) - - else: - return cls(bl_node, tree) - - @classmethod - def from_dict(cls, data, tree): - """Create all nodes from their dict representation. - - Args: - data (dict): dict nodes representation. - tree (Tree): blender node tree abstraction. - - Returns: - Node: Create abstract node. - """ - - new_bl_node = tree.bl_node_tree.nodes.new(type=data["bl_idname"]) - node = cls.from_blender_node(new_bl_node, tree) - - node.id = data["id"] - for p in node.parameters: - setattr(node, p, data[p]) - - # set attribute on the blender node only if correct type is retrieve - if p not in ("parent", "scene"): - setattr(node.bl_node, p, getattr(node, p)) - - node.inputs = [ - Input.from_dict(ipt_data, node) for ipt_data in data["inputs"].values() - ] - node.outputs = [ - Output.from_dict(opt_data, node) for opt_data in data["outputs"].values() - ] - return node - - def dump(self): - """Export currrent Node to its dict representation. - - Returns: - dict: Node dict representation. - """ - - for prop_id in self.parameters: - if not hasattr(self, prop_id): - continue - - attr_value = getattr(self, prop_id) - if attr_value is None: - attr_value = None - - elif isinstance(attr_value, Node): - attr_value = attr_value.id - - elif isinstance(attr_value, (Color, Vector)): - attr_value = list(attr_value) - - self.data[prop_id] = attr_value - - self.data["id"] = self.id - self.data["inputs"] = {ipt.id: ipt.dump() for ipt in self.inputs} - self.data["outputs"] = {opt.id: opt.dump() for opt in self.outputs} - - return self.data - - -class RenderLayersNode(Node): - """Blender Render Layers Node abstraction""" - - @property - def scene(self): - """Get the name of the scene used by the node. - - Returns: - str: scene name. - """ - if self._scene: - return self._scene.name - - @scene.setter - def scene(self, value): - """Set the blender scene using the bpy Scene object or its name. - - Args: - value (str|bpy.types.Scene): scene name or scene object to set the node. - """ - if isinstance(value, str): - self._scene = bpy.data.scenes[value] - - elif isinstance(value, bpy.types.Scene): - self._scene = value - - if self._scene: - self.bl_node.scene = self._scene - - -class Link: - """Blender Link abstraction.""" - - def __init__(self, bl_link, parent): - self.bl_link = bl_link - self.tree = parent - self.id = hex(id(self.bl_link)) - - self.input = self.bl_link.to_socket - self.output = self.bl_link.from_socket - - self.data = {} - - def dump(self): - self.data["id"] = self.id - - return self.data diff --git a/core/_node_tree.py b/core/_node_tree.py deleted file mode 100644 index 65ef8d4..0000000 --- a/core/_node_tree.py +++ /dev/null @@ -1,71 +0,0 @@ -import json -from pathlib import Path - -from .node import Node, Link - - -class NodeTree: - """Blender node tree abstraction.""" - - def __init__(self, bl_node_tree): - self.bl_node_tree = bl_node_tree - - self.data = {} - - self.links = [Link(lnk, parent=self) for lnk in self.bl_node_tree.links] - self.nodes = [] - for n in self.bl_node_tree.nodes: - self.nodes.append(Node.from_blender_node(n, self)) - - def dump(self, select_only=False): - """Convert all blender nodes and links inside the tree into a dictionnary. - - Args: - select_only (bool, optional): True to convert only selected nodes. - Defaults to False. - - Returns: - dict: Nodes and links as dict. - """ - self.data["nodes"] = { - n.id: n.dump() - for n in self.nodes - if not select_only or (select_only and n.select) - } - self.data["links"] = [l.id for l in self.links] - - return self.data - - def load(self, data): - """From a Tree dict representation, create new nodes with their attributes. - Then create a connection dict by comparing link id from inputs and outputs of each nodes. - Use this dict to link nodes between each others. - - Args: - data (dict): Tree dict representation to generate nodes and links from. - """ - - connections = {} - - self.data = data - - for node_id, node_data in self.data["nodes"].items(): - new_node = Node.from_dict(node_data, self) - self.nodes.append(new_node) - - new_node.bl_node.select = True - - for ipt in new_node.inputs: - if ipt.is_linked: - connections.setdefault(ipt.link, {})["input"] = ipt.bl_input - - for opt in new_node.outputs: - if opt.is_linked: - for link in opt.link: - connections.setdefault(link, {})["output"] = opt.bl_output - - for link_id in self.data["links"]: - ipt = connections[link_id]["input"] - opt = connections[link_id]["output"] - - self.bl_node_tree.links.new(ipt, opt) diff --git a/core/_sockets.py b/core/_sockets.py deleted file mode 100644 index 9ca2646..0000000 --- a/core/_sockets.py +++ /dev/null @@ -1,97 +0,0 @@ -class Socket: - def __init__(self, bl_socket, tree): - self.tree = tree - self.bl_socket = bl_socket - self.data = {} - - self.id = hex(id(bl_socket)) - self.identifier = bl_socket.identifier - self.is_linked = bl_socket.is_linked - - self._value = None - - if hasattr(bl_socket, "default_value"): - self._value = bl_socket.default_value - - @property - def value(self): - if not isinstance(self._value, (str, int, float, bool)): - self._value = [v for v in self._value] - - return self._value - - @value.setter - def value(self, v): - self.bl_socket.default_value = v - self._value = v - return self._value - - def to_dict(self): - self.data["id"] = self.id - self.data["value"] = self.value - self.data["identifier"] = self.identifier - self.data["is_linked"] = self.is_linked - self.data["link"] = self.get_link() - return self.data - - -class Input(Socket): - def __init__(self, bl_input, tree): - super().__init__(bl_input, tree) - - self.bl_input = bl_input - - @classmethod - def from_dict(cls, data, node): - for bl_ipt in node.bl_node.inputs: - if bl_ipt.identifier != data["identifier"]: - continue - - new_ipt = cls(bl_ipt, node.tree) - - for k, v in data.items(): - setattr(new_ipt, k, v) - - return new_ipt - - def get_link(self): - if not self.is_linked: - return None - - for ipt_link in self.bl_input.links: - for tree_link in self.tree.links: - if ipt_link == tree_link.bl_link: - return tree_link.id - - -class Output(Socket): - def __init__(self, bl_output, tree): - super().__init__(bl_output, tree) - - self.bl_output = bl_output - - @classmethod - def from_dict(cls, data, node): - for bl_opt in node.bl_node.outputs: - if bl_opt.identifier != data["identifier"]: - continue - - new_opt = cls(bl_opt, node.tree) - - for k, v in data.items(): - setattr(new_opt, k, v) - - return new_opt - - def get_link(self): - links = [] - - if not self.is_linked: - return None - - for opt_link in self.bl_output.links: - for tree_link in self.tree.links: - if opt_link == tree_link.bl_link: - links.append(tree_link.id) - - return links