gdharness 1.3.2 → 1.3.4

package/build/godot/addons/gdharness_editor/tools/scene_groups.gd

@@ -0,0 +1,91 @@
+@tool
+extends RefCounted
+
+## The groups a node of a scene is in. A scene's own file puts a node in a group and can take it
+## out of one it put it in; a group the scene that makes the node puts it in, the one it is
+## instanced from or one this scene inherits, can be changed only there, as the editor's group dock
+## shows it locked.
+
+const GdhSceneFile = preload("../scene_file.gd")
+
+
+## The groups of [param node], sorted, as {groups, groupsHere}: groupsHere, those this scene's file
+## puts it in, is given only where another scene puts it in some of them. Empty for a node in none.
+static func read(scene: GdhSceneFile, node: Node) -> Dictionary:
+	var all: Array = _sorted(node.get_groups())
+	if all.is_empty():
+		return {}
+	var answer: Dictionary = {"groups": all}
+	var here: Array = _sorted(scene.groups_at(scene.path_of(node)))
+	if here.size() != all.size():
+		answer["groupsHere"] = here
+	return answer
+
+
+## The group names under [param key] of [param args], which the server has checked are strings, or
+## none when not given.
+static func asked(args: Dictionary, key: String) -> Array:
+	var given: Variant = args.get(key)
+	return given if given is Array else []
+
+
+## Puts [param node] in each group of [param adding] and takes it out of each of [param removing],
+## or answers why not with nothing changed.
+static func change(scene: GdhSceneFile, node: Node, adding: Array, removing: Array) -> String:
+	for group: Variant in adding + removing:
+		if str(group).strip_edges().is_empty():
+			return (
+				"%s names no group: a group's name has something in it besides spaces."
+				% JSON.stringify(group)
+			)
+	for group: Variant in adding:
+		if removing.has(group):
+			return "%s is in both addGroups and removeGroups." % str(group)
+	var at: String = scene.path_of(node)
+	var here: PackedStringArray = scene.groups_at(at)
+	for group: Variant in removing:
+		var name: String = str(group)
+		if not node.is_in_group(name):
+			var held: Array = _sorted(node.get_groups())
+			return (
+				"%s is in no group %s; %s."
+				% [node.name, name, "it is in " + ", ".join(held) if not held.is_empty() else "it is in none"]
+			)
+		if not here.has(name):
+			var from: String = scene.values_from(node, at)
+			if from.is_empty():
+				return (
+					"%s is in %s, which no scene file puts it in: something puts it there as it is made, such as its script."
+					% [node.name, name]
+				)
+			return (
+				(
+					"%s is in %s because %s puts it there, and no scene using that one can take it out: "
+					+ "remove the group in %s, which takes it out in every scene using that one."
+				)
+				% [node.name, name, from, from]
+			)
+	for group: Variant in adding:
+		node.add_to_group(str(group), true)
+	for group: Variant in removing:
+		node.remove_from_group(str(group))
+	return ""
+
+
+## Why [param saved], the node as the written file loads it, is not in the groups asked, or "".
+static func unkept(saved: Node, adding: Array, removing: Array) -> String:
+	for group: Variant in adding:
+		if not saved.is_in_group(str(group)):
+			return "%s would load in no group %s." % [saved.name, str(group)]
+	for group: Variant in removing:
+		if saved.is_in_group(str(group)):
+			return "%s would still load in the group %s." % [saved.name, str(group)]
+	return ""
+
+
+static func _sorted(groups: Variant) -> Array:
+	var names: Array = []
+	for group: Variant in groups:
+		names.append(str(group))
+	names.sort()
+	return names

package/build/godot/addons/gdharness_editor/tools/scene_groups.gd.uid

@@ -0,0 +1 @@
+uid://76w2hadtl7nab

package/build/godot/addons/gdharness_editor/tools/scene_placing.gd

@@ -4,8 +4,9 @@ extends RefCounted
 ## What a new node in a scene is made or copied from, what the scene owns of it, and where among its
 ## siblings a node may go.
 
+const GdhFileWalk = preload("../file_walk.gd")
 const GdhRead = preload("../reading.gd")
-const GdhPropertyValues = preload("../property_values.gd")
+const GdhSame = preload("../same_values.gd")
 
 
 ## The scene to instance for an add, or null for a node of a class, beside why neither can be made
@@ -17,11 +18,15 @@ static func what_to_add(node_type: String, instance_path: String, scene_path: St
 			"add takes nodeType for a node of a class, or instancePath for a scene, and one of them only."
 		]
 	if not instance_path.is_empty():
+		# Asked before the cycle walk, which reads the file's dependencies and so loaded a file that
+		# was not there, laying the engine's error and a backtrace beneath the refusal.
+		if not ResourceLoader.exists(instance_path, "PackedScene"):
+			var said: String = "No scene at %s to instance" % instance_path
+			var offered: String = GdhFileWalk.new().with_nearest_files(said, instance_path)
+			return [null, offered if offered != said else said + "."]
 		var cycle: String = _instancing_cycle(scene_path, instance_path)
 		if not cycle.is_empty():
 			return [null, cycle]
-		if not ResourceLoader.exists(instance_path, "PackedScene"):
-			return [null, "No scene at %s to instance." % instance_path]
 		var packed: PackedScene = ResourceLoader.load(instance_path, "PackedScene") as PackedScene
 		if packed == null or not packed.can_instantiate():
 			return [null, "%s does not load as a scene that can be instanced." % instance_path]
@@ -35,12 +40,24 @@ static func what_to_add(node_type: String, instance_path: String, scene_path: St
 			)
 		]
 	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
-		return [null, "nodeType must be a node class, and %s is not one." % node_type]
+		return [null, not_a_node_class("nodeType", node_type)]
 	if not ClassDB.can_instantiate(node_type):
 		return [null, "%s cannot be instantiated." % node_type]
 	return [null, ""]
 
 
+## The refusal for [param given], sent as [param argument], which names no node class, with the
+## node classes nearest it, so "Node2DD" is offered Node2D.
+static func not_a_node_class(argument: String, given: String) -> String:
+	var said: String = "%s must be a node class, and %s is not one" % [argument, given]
+	var classes: PackedStringArray = ClassDB.get_inheriters_from_class("Node")
+	var _added: bool = classes.append("Node")
+	var close: PackedStringArray = GdhRead.nearest(given, classes)
+	if close.is_empty():
+		return said + "."
+	return "%s; the nearest %s %s." % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+
+
 ## A new node of [param node_type], or an instance of [param packed] when there is one. The instance
 ## is made in the editor's edit state, so the pack writes it as an instance of its file, and owning
 ## its root leaves its own nodes to the instanced scene.
@@ -68,7 +85,7 @@ static func copied(source: Node, root: Node, copies: Dictionary) -> Node:
 				continue
 			var property: String = str(declared.get("name", ""))
 			var value: Variant = source.get(property)
-			if not GdhPropertyValues.same(copy.get(property), value):
+			if not GdhSame.same(copy.get(property), value):
 				copy.set(property, value)
 		for group: StringName in source.get_groups():
 			if not copy.is_in_group(group):
@@ -154,6 +171,72 @@ static func place(node: Node, asked: Variant) -> void:
 		node.get_parent().move_child(node, GdhRead.as_int(asked))
 
 
+## The properties that hold where [param node] is drawn, which a reparent keeping it in place
+## changes: a Control keeps only its position, as Node.reparent keeps it.
+static func placing(node: Node) -> Array[String]:
+	if node is Node3D:
+		return ["position", "rotation", "scale"]
+	if node is Control:
+		return ["position"]
+	if node is Node2D:
+		return ["position", "rotation", "scale", "skew"]
+	return []
+
+
+## Gives [param node], just moved from under [param was], the transform that keeps it where it was
+## drawn, as the editor's reparent and Node.reparent do. Worked out from the local transforms
+## rather than read off the global ones, which the engine answers only for a node in the tree, and
+## the scene a tool edits is loaded from its file and never is. Nothing changes for a top-level
+## node, or where the old and new parents place their children alike.
+static func keep_in_place(node: Node, was: Node) -> void:
+	if node is Node3D:
+		var spatial: Node3D = node
+		var before: Transform3D = _spatial_space(was)
+		var after: Transform3D = _spatial_space(node.get_parent())
+		if not spatial.top_level and not before.is_equal_approx(after):
+			spatial.transform = after.affine_inverse() * before * spatial.transform
+	elif node is CanvasItem:
+		var drawn: CanvasItem = node
+		var before_2d: Transform2D = _canvas_space(was)
+		var after_2d: Transform2D = _canvas_space(node.get_parent())
+		if drawn.top_level or before_2d.is_equal_approx(after_2d):
+			return
+		var held: Transform2D = after_2d.affine_inverse() * before_2d * drawn.get_transform()
+		if node is Control:
+			var control: Control = node
+			control.position = held.origin
+		else:
+			var flat: Node2D = node
+			flat.transform = held
+
+
+## Where the children of [param parent] are drawn in 3D: the transforms of it and the Node3Ds
+## above it, up to the first that is top-level or whose parent is no Node3D.
+static func _spatial_space(parent: Node) -> Transform3D:
+	var space: Transform3D = Transform3D.IDENTITY
+	var at: Node = parent
+	while at is Node3D:
+		var spatial: Node3D = at
+		space = spatial.transform * space
+		if spatial.top_level:
+			break
+		at = at.get_parent()
+	return space
+
+
+## Where the children of [param parent] are drawn in 2D, as [method _spatial_space] works it out in 3D.
+static func _canvas_space(parent: Node) -> Transform2D:
+	var space: Transform2D = Transform2D.IDENTITY
+	var at: Node = parent
+	while at is CanvasItem:
+		var drawn: CanvasItem = at
+		space = drawn.get_transform() * space
+		if drawn.top_level:
+			break
+		at = at.get_parent()
+	return space
+
+
 ## Why [param instanced] cannot be instanced into [param scene_path], or "" when it can: a scene
 ## inside itself, directly or through the scenes it instances, which Godot's own dialog refuses and
 ## which never finishes loading.