mirror of
https://github.com/Relintai/material-maker.git
synced 2024-12-23 21:16:54 +01:00
400 lines
12 KiB
GDScript
400 lines
12 KiB
GDScript
extends GraphEdit
|
|
class_name MMGraphEdit
|
|
|
|
var editor_interface = null
|
|
var node_factory = null
|
|
|
|
var save_path = null setget set_save_path
|
|
var need_save = false
|
|
|
|
var top_generator = null
|
|
var generator = null
|
|
|
|
var last_selected = null
|
|
|
|
onready var node_popup = $"../AddNodePopup"
|
|
|
|
onready var timer : Timer = $Timer
|
|
|
|
onready var subgraph_ui : HBoxContainer = $GraphUI/SubGraphUI
|
|
onready var button_transmits_seed : Button = $GraphUI/SubGraphUI/ButtonTransmitsSeed
|
|
|
|
signal save_path_changed
|
|
signal graph_changed
|
|
|
|
func _ready() -> void:
|
|
OS.low_processor_usage_mode = true
|
|
center_view()
|
|
for t in range(41):
|
|
add_valid_connection_type(t, 42)
|
|
add_valid_connection_type(42, t)
|
|
|
|
func _gui_input(event) -> void:
|
|
if event is InputEventKey and event.pressed:
|
|
var scancode_with_modifiers = event.get_scancode_with_modifiers()
|
|
if scancode_with_modifiers == KEY_DELETE or scancode_with_modifiers == KEY_BACKSPACE:
|
|
remove_selection()
|
|
return
|
|
if event is InputEventMouseMotion and event.button_mask == 0:
|
|
for c in get_children():
|
|
if c is GraphNode and Rect2(c.rect_global_position, c.rect_size*c.get_global_transform().get_scale()).has_point(event.global_position):
|
|
hint_tooltip = c.get_slot_tooltip(c.get_global_transform().xform_inv(event.global_position))
|
|
|
|
# Misc. useful functions
|
|
func get_source(node, port) -> Dictionary:
|
|
for c in get_connection_list():
|
|
if c.to == node and c.to_port == port:
|
|
return { node=c.from, slot=c.from_port }
|
|
return {}
|
|
|
|
func offset_from_global_position(global_position) -> Vector2:
|
|
return (scroll_offset + global_position - rect_global_position) / zoom
|
|
|
|
func add_node(node) -> void:
|
|
add_child(node)
|
|
move_child(node, 0)
|
|
node.connect("close_request", self, "remove_node", [ node ])
|
|
|
|
func connect_node(from, from_slot, to, to_slot):
|
|
var from_node : MMGraphNodeBase = get_node(from)
|
|
var to_node : MMGraphNodeBase = get_node(to)
|
|
if generator.connect_children(from_node.generator, from_slot, to_node.generator, to_slot):
|
|
var disconnect = get_source(to, to_slot)
|
|
if !disconnect.empty():
|
|
.disconnect_node(disconnect.node, disconnect.slot, to, to_slot)
|
|
.connect_node(from, from_slot, to, to_slot)
|
|
send_changed_signal()
|
|
|
|
func disconnect_node(from, from_slot, to, to_slot) -> void:
|
|
if generator.disconnect_children(get_node(from).generator, from_slot, get_node(to).generator, to_slot):
|
|
.disconnect_node(from, from_slot, to, to_slot)
|
|
send_changed_signal()
|
|
|
|
func on_connections_changed(removed_connections : Array, added_connections : Array) -> void:
|
|
for c in removed_connections:
|
|
.disconnect_node("node_"+c.from, c.from_port, "node_"+c.to, c.to_port)
|
|
for c in added_connections:
|
|
.connect_node("node_"+c.from, c.from_port, "node_"+c.to, c.to_port)
|
|
|
|
func remove_node(node) -> void:
|
|
if generator.remove_generator(node.generator):
|
|
var node_name = node.name
|
|
for c in get_connection_list():
|
|
if c.from == node_name or c.to == node_name:
|
|
disconnect_node(c.from, c.from_port, c.to, c.to_port)
|
|
if node == last_selected:
|
|
set_last_selected(null)
|
|
remove_child(node)
|
|
node.queue_free()
|
|
send_changed_signal()
|
|
|
|
# Global operations on graph
|
|
|
|
func update_tab_title() -> void:
|
|
if !get_parent().has_method("set_tab_title"):
|
|
print("no set_tab_title method")
|
|
return
|
|
var title = "[unnamed]"
|
|
if save_path != null:
|
|
title = save_path.right(save_path.rfind("/")+1)
|
|
if need_save:
|
|
title += " *"
|
|
if get_parent().has_method("set_tab_title"):
|
|
get_parent().set_tab_title(get_index(), title)
|
|
|
|
func set_need_save(ns) -> void:
|
|
if ns != need_save:
|
|
need_save = ns
|
|
update_tab_title()
|
|
|
|
func set_save_path(path) -> void:
|
|
if path != save_path:
|
|
save_path = path
|
|
update_tab_title()
|
|
emit_signal("save_path_changed", self, path)
|
|
|
|
func clear_view() -> void:
|
|
clear_connections()
|
|
for c in get_children():
|
|
if c is GraphNode:
|
|
if c == last_selected:
|
|
set_last_selected(null)
|
|
remove_child(c)
|
|
c.free()
|
|
|
|
# Center view
|
|
|
|
func center_view() -> void:
|
|
var center = Vector2(0, 0)
|
|
var node_count = 0
|
|
for c in get_children():
|
|
if c is GraphNode:
|
|
center += c.offset + 0.5*c.rect_size
|
|
node_count += 1
|
|
if node_count > 0:
|
|
center /= node_count
|
|
scroll_offset = center - 0.5*rect_size
|
|
|
|
func update_view(g) -> void:
|
|
if generator != null:
|
|
generator.disconnect("connections_changed", self, "on_connections_changed")
|
|
clear_view()
|
|
generator = g
|
|
if generator != null:
|
|
generator.connect("connections_changed", self, "on_connections_changed")
|
|
update_graph(generator.get_children(), generator.connections)
|
|
subgraph_ui.visible = generator != top_generator
|
|
subgraph_ui.get_node("Label").text = generator.label
|
|
center_view()
|
|
if generator.get_parent() is MMGenGraph:
|
|
button_transmits_seed.visible = true
|
|
button_transmits_seed.pressed = generator.transmits_seed
|
|
else:
|
|
button_transmits_seed.visible = false
|
|
|
|
|
|
func clear_material() -> void:
|
|
if top_generator != null:
|
|
remove_child(top_generator)
|
|
top_generator.free()
|
|
top_generator = null
|
|
generator = null
|
|
send_changed_signal()
|
|
|
|
func update_graph(generators, connections) -> Array:
|
|
var rv = []
|
|
for g in generators:
|
|
var node = node_factory.create_node(g.get_type())
|
|
if node != null:
|
|
node.name = "node_"+g.name
|
|
add_node(node)
|
|
node.generator = g
|
|
node.offset = g.position
|
|
rv.push_back(node)
|
|
for c in connections:
|
|
.connect_node("node_"+c.from, c.from_port, "node_"+c.to, c.to_port)
|
|
|
|
return rv
|
|
|
|
func new_material() -> void:
|
|
clear_material()
|
|
top_generator = mm_loader.create_gen({nodes=[{name="Material", type="material","parameters":{"size":11}}], connections=[]})
|
|
if top_generator != null:
|
|
add_child(top_generator)
|
|
move_child(top_generator, 0)
|
|
update_view(top_generator)
|
|
center_view()
|
|
set_save_path(null)
|
|
set_need_save(false)
|
|
|
|
func get_free_name(type) -> String:
|
|
var i = 0
|
|
while true:
|
|
var node_name = type+"_"+str(i)
|
|
if !has_node(node_name):
|
|
return node_name
|
|
i += 1
|
|
return ""
|
|
|
|
func create_nodes(data, position : Vector2 = Vector2(0, 0)) -> Array:
|
|
if !data is Dictionary:
|
|
return []
|
|
if data.has("type"):
|
|
data = { nodes=[data], connections=[] }
|
|
if data.has("nodes") and typeof(data.nodes) == TYPE_ARRAY and data.has("connections") and typeof(data.connections) == TYPE_ARRAY:
|
|
var new_stuff = mm_loader.add_to_gen_graph(generator, data.nodes, data.connections)
|
|
for g in new_stuff.generators:
|
|
g.position += position
|
|
return update_graph(new_stuff.generators, new_stuff.connections)
|
|
return []
|
|
|
|
func create_gen_from_type(gen_name) -> void:
|
|
create_nodes({ type=gen_name, parameters={} }, scroll_offset+0.5*rect_size)
|
|
|
|
func load_file(filename) -> void:
|
|
clear_material()
|
|
top_generator = mm_loader.load_gen(filename)
|
|
if top_generator != null:
|
|
add_child(top_generator)
|
|
move_child(top_generator, 0)
|
|
update_view(top_generator)
|
|
center_view()
|
|
set_save_path(filename)
|
|
set_need_save(false)
|
|
|
|
func save_file(filename) -> void:
|
|
var data = top_generator.serialize()
|
|
var file = File.new()
|
|
if file.open(filename, File.WRITE) == OK:
|
|
file.store_string(JSON.print(data, "\t", true))
|
|
file.close()
|
|
set_save_path(filename)
|
|
set_need_save(false)
|
|
|
|
func get_material_node() -> MMGenMaterial:
|
|
for g in top_generator.get_children():
|
|
if g.has_method("get_export_profiles"):
|
|
return g
|
|
return null
|
|
|
|
func export_material(export_prefix, profile) -> void:
|
|
for g in top_generator.get_children():
|
|
if g.has_method("export_material"):
|
|
g.export_material(export_prefix, profile)
|
|
|
|
# Cut / copy / paste / duplicate
|
|
|
|
func get_selected_nodes() -> Array:
|
|
var selected_nodes = []
|
|
for n in get_children():
|
|
if n is GraphNode and n.selected:
|
|
selected_nodes.append(n)
|
|
return selected_nodes
|
|
|
|
func remove_selection() -> void:
|
|
for c in get_children():
|
|
if c is GraphNode and c.selected and c.name != "Material":
|
|
remove_node(c)
|
|
|
|
# Maybe move this to gen_graph...
|
|
func serialize_selection() -> Dictionary:
|
|
var data = { nodes = [], connections = [] }
|
|
var nodes = []
|
|
for c in get_children():
|
|
if c is GraphNode and c.selected and c.name != "Material":
|
|
nodes.append(c)
|
|
if nodes.empty():
|
|
return {}
|
|
var center = Vector2(0, 0)
|
|
for n in nodes:
|
|
center += n.offset+0.5*n.rect_size
|
|
center /= nodes.size()
|
|
for n in nodes:
|
|
var s = n.generator.serialize()
|
|
var p = n.offset-center
|
|
s.node_position = { x=p.x, y=p.y }
|
|
data.nodes.append(s)
|
|
for c in get_connection_list():
|
|
var from = get_node(c.from)
|
|
var to = get_node(c.to)
|
|
if from != null and from.selected and to != null and to.selected:
|
|
var connection = c.duplicate(true)
|
|
connection.from = from.generator.name
|
|
connection.to = to.generator.name
|
|
data.connections.append(connection)
|
|
return data
|
|
|
|
func can_copy() -> bool:
|
|
for c in get_children():
|
|
if c is GraphNode and c.selected and c.name != "Material":
|
|
return true
|
|
return false
|
|
|
|
func cut() -> void:
|
|
copy()
|
|
remove_selection()
|
|
|
|
func copy() -> void:
|
|
OS.clipboard = to_json(serialize_selection())
|
|
|
|
func do_paste(data) -> void:
|
|
var position = scroll_offset+0.5*rect_size
|
|
if Rect2(Vector2(0, 0), rect_size).has_point(get_local_mouse_position()):
|
|
position = offset_from_global_position(get_global_transform().xform(get_local_mouse_position()))
|
|
for c in get_children():
|
|
if c is GraphNode:
|
|
c.selected = false
|
|
var new_nodes = create_nodes(data, position)
|
|
if new_nodes != null:
|
|
for c in new_nodes:
|
|
c.selected = true
|
|
|
|
func paste() -> void:
|
|
do_paste(parse_json(OS.clipboard))
|
|
|
|
func duplicate_selected() -> void:
|
|
do_paste(serialize_selection())
|
|
|
|
# Delay after graph update
|
|
|
|
func send_changed_signal() -> void:
|
|
set_need_save(true)
|
|
timer.stop()
|
|
timer.start(0.2)
|
|
|
|
func do_send_changed_signal() -> void:
|
|
emit_signal("graph_changed")
|
|
|
|
# Drag and drop
|
|
|
|
func can_drop_data(position, data) -> bool:
|
|
return typeof(data) == TYPE_DICTIONARY and (data.has('type') or (data.has('nodes') and data.has('connections')))
|
|
|
|
func drop_data(position, data) -> void:
|
|
# The following mitigates the SpinBox problem (captures mouse while dragging)
|
|
if Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED:
|
|
Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
|
|
create_nodes(data, offset_from_global_position(get_global_transform().xform(position)))
|
|
|
|
func on_ButtonUp_pressed() -> void:
|
|
if generator != top_generator && generator.get_parent() is MMGenGraph:
|
|
call_deferred("update_view", generator.get_parent())
|
|
|
|
func _on_Label_text_changed(new_text) -> void:
|
|
generator.label = new_text
|
|
|
|
# Create subgraph
|
|
|
|
func create_subgraph() -> void:
|
|
var generators = []
|
|
for n in get_selected_nodes():
|
|
generators.push_back(n.generator)
|
|
var subgraph = generator.create_subgraph(generators)
|
|
if subgraph != null:
|
|
update_view(subgraph)
|
|
|
|
func _on_ButtonShowTree_pressed() -> void:
|
|
var graph_tree : Popup = preload("res://material_maker/widgets/graph_tree/graph_tree.tscn").instance()
|
|
add_child(graph_tree)
|
|
graph_tree.init("Top", top_generator)
|
|
graph_tree.connect("item_double_clicked", self, "edit_subgraph")
|
|
graph_tree.popup_centered()
|
|
|
|
func edit_subgraph(g : MMGenGraph) -> void:
|
|
if !g.is_editable():
|
|
g.toggle_editable()
|
|
update_view(g)
|
|
|
|
|
|
func _on_ButtonTransmitsSeed_toggled(button_pressed) -> void:
|
|
if button_pressed != generator.transmits_seed:
|
|
generator.transmits_seed = button_pressed
|
|
|
|
func _on_GraphEdit_node_selected(node) -> void:
|
|
set_last_selected(node)
|
|
|
|
func set_last_selected(node) -> void:
|
|
if node is GraphNode:
|
|
last_selected = node
|
|
else:
|
|
last_selected = null
|
|
|
|
func _on_GraphEdit_gui_input(event) -> void:
|
|
if event.is_action_pressed("ui_library_popup") && get_rect().has_point(get_local_mouse_position()):
|
|
node_popup.rect_global_position = get_global_mouse_position()
|
|
node_popup.show()
|
|
if event is InputEventMouseButton:
|
|
call_deferred("check_last_selected")
|
|
|
|
func request_popup(from, from_slot, release_position) -> void:
|
|
node_popup.rect_global_position = get_global_mouse_position()
|
|
node_popup.show()
|
|
node_popup.set_quick_connect(from, from_slot)
|
|
|
|
func check_last_selected() -> void:
|
|
if last_selected != null and !(is_instance_valid(last_selected) and last_selected.selected):
|
|
last_selected = null
|
|
emit_signal("node_selected", null)
|
|
|
|
|