mirror of
https://codeberg.org/StreamGraph/StreamGraph.git
synced 2024-11-13 19:49:55 +01:00
338 lines
11 KiB
GDScript
338 lines
11 KiB
GDScript
class_name Deck
|
|
## A deck/graph with nodes.
|
|
##
|
|
## A container for [DeckNode]s, managing connections between them.
|
|
|
|
## The [DeckNode]s that belong to this deck. The key is the node's id, the value
|
|
## is the [DeckNode] instance.
|
|
var nodes: Dictionary
|
|
|
|
|
|
## A map of variables set on this deck.
|
|
var variable_stack: Dictionary = {}
|
|
## The path to save this deck on the file system.
|
|
var save_path: String = ""
|
|
|
|
var is_group: bool = false
|
|
## List of groups belonging to this deck, in the format of[br]
|
|
## [code]Dictionary[String -> Deck.id, Deck][/code]
|
|
var groups: Dictionary = {}
|
|
## A unique identifier for this deck.
|
|
var id: String = ""
|
|
## The parent deck of this deck, if this is a group.
|
|
var _belonging_to: Deck # for groups
|
|
## The ID of this group's input node. Used only if [member is_group] is [code]true[/code].
|
|
var group_input_node: String
|
|
## The ID of this group's input node. Used only if [member is_group] is [code]true[/code].
|
|
var group_output_node: String
|
|
## The ID of the group node this group is represented by, contained in this deck's parent deck.
|
|
## Used only if [member is_group] is [code]true[/code].
|
|
## @experimental
|
|
var group_node: String
|
|
|
|
## Emitted when a node has been added to this deck.
|
|
signal node_added(node: DeckNode)
|
|
## Emitted when a node has been removed from this deck.
|
|
signal node_removed(node: DeckNode)
|
|
|
|
|
|
## Instantiate a node by its' [member DeckNode.node_type] and add it to this deck.[br]
|
|
## See [method add_node_inst] for parameter descriptions.
|
|
func add_node_type(type: String, assign_id: String = "", assign_to_self: bool = true) -> DeckNode:
|
|
var node_inst: DeckNode = NodeDB.instance_node(type)
|
|
|
|
return add_node_inst(node_inst, assign_id, assign_to_self)
|
|
|
|
|
|
## Add a [DeckNode] instance to this deck.[br]
|
|
## If [param assign_id] is empty, the node will get its' ID (re-)assigned.
|
|
## Otherwise, it will be assigned to be that value.[br]
|
|
## If [param assign_to_self] is [code]true[/code], the node's
|
|
## [member DeckNode._belonging_to] property will be set to [code]self[/code].
|
|
func add_node_inst(node: DeckNode, assign_id: String = "", assign_to_self: bool = true) -> DeckNode:
|
|
if assign_to_self:
|
|
node._belonging_to = self
|
|
|
|
if assign_id == "":
|
|
var uuid := UUID.v4()
|
|
nodes[uuid] = node
|
|
node._id = uuid
|
|
else:
|
|
nodes[assign_id] = node
|
|
node._id = assign_id
|
|
|
|
node_added.emit(node)
|
|
|
|
return node
|
|
|
|
|
|
## Get a node belonging to this deck by its' ID.
|
|
func get_node(uuid: String) -> DeckNode:
|
|
return nodes.get(uuid)
|
|
|
|
|
|
## Attempt to connect two nodes. Returns [code]true[/code] if the connection succeeded.
|
|
func connect_nodes(from_node_id: String, to_node_id: String, from_output_port: int, to_input_port: int) -> bool:
|
|
var from_node := get_node(from_node_id)
|
|
var to_node := get_node(to_node_id)
|
|
# check that we can do the type conversion
|
|
var type_a: DeckType.Types = from_node.get_output_ports()[from_output_port].type
|
|
var type_b: DeckType.Types = to_node.get_input_ports()[to_input_port].type
|
|
if !DeckType.can_convert(type_a, type_b):
|
|
print("Can not convert from %s to %s." % [DeckType.type_str(type_a), DeckType.type_str(type_b)])
|
|
return false
|
|
|
|
# TODO: prevent duplicate connections
|
|
|
|
from_node.add_outgoing_connection(from_output_port, to_node._id, to_input_port)
|
|
return true
|
|
|
|
|
|
## Remove a connection from two nodes.
|
|
func disconnect_nodes(from_node_id: String, to_node_id: String, from_output_port: int, to_input_port: int) -> void:
|
|
var from_node := get_node(from_node_id)
|
|
var to_node := get_node(to_node_id)
|
|
from_node.remove_outgoing_connection(from_output_port, to_node_id, to_input_port)
|
|
to_node.remove_incoming_connection(to_input_port)
|
|
|
|
|
|
## Returns true if this deck has no nodes and no variables.
|
|
func is_empty() -> bool:
|
|
return nodes.is_empty() && variable_stack.is_empty()
|
|
|
|
|
|
## Remove a node from this deck.
|
|
func remove_node(uuid: String, remove_connections: bool = false) -> void:
|
|
var node := get_node(uuid)
|
|
if node == null:
|
|
return
|
|
|
|
if remove_connections:
|
|
var outgoing_connections := node.outgoing_connections.duplicate(true)
|
|
|
|
for output_port: int in outgoing_connections:
|
|
for connection: Dictionary in outgoing_connections[output_port]:
|
|
disconnect_nodes(uuid, connection.keys()[0], output_port, connection.values()[0])
|
|
|
|
var incoming_connections := node.incoming_connections.duplicate(true)
|
|
|
|
for input_port: int in incoming_connections:
|
|
for from_node: String in incoming_connections[input_port]:
|
|
disconnect_nodes(from_node, uuid, incoming_connections[input_port][from_node], input_port)
|
|
|
|
nodes.erase(uuid)
|
|
|
|
node_removed.emit(node)
|
|
|
|
|
|
## Group the [param nodes_to_group] into a new deck and return it.
|
|
## Returns [code]null[/code] on failure.[br]
|
|
## Adds a group node to this deck, and adds group input and output nodes in the group.
|
|
func group_nodes(nodes_to_group: Array) -> Deck:
|
|
if nodes_to_group.is_empty():
|
|
return null
|
|
|
|
var node_ids_to_keep := nodes_to_group.map(
|
|
func(x: DeckNode):
|
|
return x._id
|
|
)
|
|
|
|
var group := Deck.new()
|
|
group.is_group = true
|
|
group._belonging_to = self
|
|
var group_id := UUID.v4()
|
|
group.id = group_id
|
|
|
|
var midpoint := Vector2()
|
|
for node: DeckNode in nodes_to_group:
|
|
if node.node_type == "group_node": # for recursive grouping
|
|
var _group_id: String = node.group_id
|
|
var _group: Deck = groups[_group_id]
|
|
groups.erase(_group)
|
|
group.groups[_group_id] = _group
|
|
_group._belonging_to = group
|
|
|
|
var outgoing_connections := node.outgoing_connections.duplicate(true)
|
|
|
|
for from_port: int in outgoing_connections:
|
|
for connection: Dictionary in outgoing_connections[from_port]:
|
|
if !(connection.keys()[0] in node_ids_to_keep):
|
|
disconnect_nodes(node._id, connection.keys()[0], from_port, connection.values()[0])
|
|
|
|
var incoming_connections := node.incoming_connections.duplicate(true)
|
|
|
|
for to_port: int in incoming_connections:
|
|
for from_node: String in incoming_connections[to_port]:
|
|
if !(from_node in node_ids_to_keep):
|
|
disconnect_nodes(from_node, node._id, incoming_connections[to_port][from_node], to_port)
|
|
|
|
midpoint += node.position_as_vector2()
|
|
remove_node(node._id)
|
|
group.add_node_inst(node, node._id)
|
|
|
|
midpoint /= nodes_to_group.size()
|
|
|
|
var _group_node := add_node_type("group_node")
|
|
_group_node.group_id = group_id
|
|
_group_node.position.x = midpoint.x
|
|
_group_node.position.y = midpoint.y
|
|
_group_node.position_updated.emit(_group_node.position)
|
|
group.group_node = _group_node._id
|
|
|
|
var input_node := group.add_node_type("group_input")
|
|
var output_node := group.add_node_type("group_output")
|
|
group.group_input_node = input_node._id
|
|
group.group_output_node = output_node._id
|
|
|
|
_group_node.input_node = input_node
|
|
_group_node.output_node = output_node
|
|
_group_node.setup_connections()
|
|
|
|
groups[group_id] = group
|
|
|
|
return group
|
|
|
|
|
|
## Get a group belonging to this deck by its ID.
|
|
func get_group(uuid: String) -> Deck:
|
|
return groups.get(uuid)
|
|
|
|
|
|
func copy_nodes_json(nodes_to_copy: Array[String]) -> String:
|
|
var d := {"nodes": {}}
|
|
|
|
for node_id: String in nodes_to_copy:
|
|
d.nodes[node_id] = get_node(node_id).to_dict()
|
|
|
|
for node: String in d.nodes:
|
|
var outgoing_connections: Dictionary = d.nodes[node].outgoing_connections.duplicate(true)
|
|
|
|
for from_port: int in outgoing_connections:
|
|
for to_node: String in outgoing_connections[from_port]:
|
|
if !(to_node in nodes_to_copy):
|
|
(d.nodes[node].outgoing_connections[from_port] as Dictionary).erase(to_node)
|
|
|
|
var incoming_connections: Dictionary = d.nodes[node].incoming_connections.duplicate(true)
|
|
|
|
for to_port: int in incoming_connections:
|
|
for from_node: String in incoming_connections[to_port]:
|
|
if !(from_node in nodes_to_copy):
|
|
(d.nodes[node].incoming_connections[to_port] as Dictionary).erase(from_node)
|
|
|
|
for node: Dictionary in d.nodes.values().slice(1):
|
|
node.position.x = node.position.x - d.nodes.values()[0].position.x
|
|
node.position.y = node.position.y - d.nodes.values()[0].position.y
|
|
|
|
d.nodes.values()[0].position.x = 0
|
|
d.nodes.values()[0].position.y = 0
|
|
|
|
return JSON.stringify(d)
|
|
|
|
|
|
func allocate_ids(count: int) -> Array[String]:
|
|
var res: Array[String]
|
|
for i in count:
|
|
res.append(UUID.v4())
|
|
return res
|
|
|
|
|
|
func paste_nodes_from_json(json: String, position: Vector2 = Vector2()) -> void:
|
|
var d: Dictionary = JSON.parse_string(json) as Dictionary
|
|
if !d.get("nodes"):
|
|
return
|
|
|
|
var new_ids := allocate_ids(d.nodes.size())
|
|
var ids_map := {}
|
|
for i: int in d.nodes.keys().size():
|
|
var node_id: String = d.nodes.keys()[i]
|
|
ids_map[node_id] = new_ids[i]
|
|
|
|
var new_json := json
|
|
for old_id: String in ids_map:
|
|
new_json = new_json.replace(old_id, ids_map[old_id])
|
|
|
|
for node_id: String in d.nodes:
|
|
d.nodes[node_id]._id = ids_map[node_id]
|
|
|
|
d.nodes[node_id].position.x += position.x
|
|
d.nodes[node_id].position.y += position.y
|
|
|
|
var outgoing_connections: Dictionary = d.nodes[node_id].outgoing_connections as Dictionary
|
|
var outgoing_connections_res := {}
|
|
for from_port: String in outgoing_connections:
|
|
outgoing_connections_res[from_port] = {}
|
|
for to_node_id: String in outgoing_connections[from_port]:
|
|
outgoing_connections_res[from_port][ids_map[to_node_id]] = outgoing_connections[from_port][to_node_id]
|
|
|
|
var incoming_connections: Dictionary = d.nodes[node_id].incoming_connections as Dictionary
|
|
var incoming_connections_res := {}
|
|
for to_port: String in incoming_connections:
|
|
incoming_connections_res[to_port] = {}
|
|
for from_node_id: String in incoming_connections[to_port]:
|
|
incoming_connections_res[to_port][ids_map[from_node_id]] = incoming_connections[to_port][from_node_id]
|
|
|
|
d.nodes[node_id].outgoing_connections = outgoing_connections_res
|
|
d.nodes[node_id].incoming_connections = incoming_connections_res
|
|
|
|
var node := DeckNode.from_dict(d.nodes[node_id])
|
|
add_node_inst(node, ids_map[node_id])
|
|
|
|
|
|
## Returns a [Dictionary] representation of this deck.
|
|
func to_dict(with_meta: bool = true) -> Dictionary:
|
|
var inner := {
|
|
"nodes": {},
|
|
"variable_stack": variable_stack,
|
|
"id": id,
|
|
"groups": {}
|
|
}
|
|
|
|
for node_id in nodes.keys():
|
|
inner["nodes"][node_id] = nodes[node_id].to_dict(with_meta)
|
|
|
|
for group_id in groups.keys():
|
|
inner["groups"][group_id] = groups[group_id].to_dict(with_meta)
|
|
|
|
if is_group:
|
|
inner["group_node"] = group_node
|
|
inner["group_input_node"] = group_input_node
|
|
inner["group_output_node"] = group_output_node
|
|
|
|
var d := {"deck": inner}
|
|
|
|
if with_meta:
|
|
d["meta"] = {}
|
|
for meta in get_meta_list():
|
|
d["meta"][meta] = var_to_str(get_meta(meta))
|
|
return d
|
|
|
|
|
|
## Create a new deck from a [Dictionary] representation, such as one created by [method to_dict].
|
|
static func from_dict(data: Dictionary, path: String = "") -> Deck:
|
|
var deck := Deck.new()
|
|
deck.save_path = path
|
|
deck.variable_stack = data.deck.variable_stack
|
|
deck.id = data.deck.id
|
|
|
|
for key in data.meta:
|
|
deck.set_meta(key, str_to_var(data.meta[key]))
|
|
|
|
var nodes_data: Dictionary = data.deck.nodes as Dictionary
|
|
|
|
for node_id in nodes_data:
|
|
var node := DeckNode.from_dict(nodes_data[node_id])
|
|
deck.add_node_inst(node, node_id)
|
|
|
|
var groups_data: Dictionary = data.deck.groups as Dictionary
|
|
|
|
for group_id: String in groups_data:
|
|
var group := Deck.from_dict(groups_data[group_id])
|
|
group._belonging_to = deck
|
|
group.is_group = true
|
|
deck.groups[group_id] = group
|
|
group.group_node = groups_data[group_id]["deck"]["group_node"]
|
|
group.group_input_node = groups_data[group_id]["deck"]["group_input_node"]
|
|
group.group_output_node = groups_data[group_id]["deck"]["group_output_node"]
|
|
deck.get_node(group.group_node).init_io()
|
|
|
|
return deck
|