gdharness 1.1.21 → 1.1.23

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -1,7 +1,8 @@
 extends RefCounted
 
 ## What the server asks about the running tree: its shape, one node, the nodes matching a
-## question, where one is on screen, a property set, a method called, the metrics.
+## question, where one is on screen, a property's value, the metrics. What it changes, a property
+## written or a method called, is in runtime_changes.gd.
 
 const Paths = preload("runtime_paths.gd")
 const Read = preload("reading.gd")
@@ -13,7 +14,6 @@ const Words = preload("runtime_words.gd")
 ## The most nodes one find answers with, unless asked for fewer: enough for any real query and
 ## far short of the tree dump a query exists to avoid.
 const FIND_LIMIT: int = 100
-const FIND_LIMIT_CEILING: int = 1000
 
 ## What a find can be narrowed by, which is also what it refuses to answer without. Named once so
 ## the refusal lists the same set the walk reads.
@@ -23,6 +23,11 @@ const FILTERS: PackedStringArray = ["class", "script", "name", "group", "says"]
 ## thousand is a tree somebody pointed this at by mistake.
 const READ_LIMIT: int = 500
 
+## The most either can be asked for. A limit above it is refused rather than cut to it: the ceiling
+## was the default for a read, so the remedy its own answer gave, raising the limit, changed nothing
+## and said nothing, and a caller told to raise a number that stays put concludes the screen moved.
+const LIMIT_CEILING: int = 5000
+
 var _host: Node
 var _values: Values
 
@@ -87,7 +92,11 @@ func find_nodes(params: Dictionary) -> Dictionary:
 		wanted[filter] = str(params.get(filter, ""))
 	var wanted_property: String = str(params.get("property", ""))
 	var include_hidden: bool = Read.as_bool(params.get("include_hidden", true), true)
-	var limit: int = clampi(Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT), 1, FIND_LIMIT_CEILING)
+	var limit: int = Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT)
+	if limit < 1 or limit > LIMIT_CEILING:
+		return {
+			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
+		}
 
 	if not _anything_asked(wanted):
 		return {"type": "error", "message": "find_nodes needs at least one of " + ", ".join(FILTERS)}
@@ -115,6 +124,10 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	for filter: String in wanted:
 		widened[filter] = widened_says if filter == "says" else wanted[filter]
 	var nearly_said: int = 0
+	# The near misses the same find would leave out as hidden, kept apart: the note says what a
+	# query would find, and counting these in it named a query that, asked, found none of them.
+	var nearly_hidden: int = 0
+	var nearly_said_hidden: int = 0
 	var hidden: int = 0
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
@@ -128,13 +141,19 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			else:
 				found.append(_found(node, wanted_property))
 		elif rest and literal and str(node.name).containsn(wanted["name"]):
-			nearly += 1
+			if include_hidden or shown(node):
+				nearly += 1
+			else:
+				nearly_hidden += 1
 		elif (
 			not widened_says.is_empty()
 			and _named(node, wanted["name"])
 			and _matches_apart_from_name(node, widened)
 		):
-			nearly_said += 1
+			if include_hidden or shown(node):
+				nearly_said += 1
+			else:
+				nearly_said_hidden += 1
 		# Internal children included, which they were not. A ConfirmationDialog builds its Yes and
 		# its No as internal nodes, and a ScrollContainer its bars, so a find over a screen for
 		# every Button came back without the two buttons the player is being asked to press:
@@ -150,21 +169,39 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	# Nothing found is the one answer that cannot be told apart from having asked the wrong
 	# question, and a name written without a wildcard is the way an agent writes "contains".
 	# Said only when it changes the answer, so a genuine nothing stays a plain nothing.
-	if found.is_empty() and nearly > 0:
-		var holding: String = "names contain" if nearly > 1 else "name contains"
-		notes.append(
-			(
-				'name is matched as a glob against the whole name; %d node %s "%s", which "*%s*" would find'
-				% [nearly, holding, wanted["name"], wanted["name"]]
+	if found.is_empty() and nearly + nearly_hidden > 0:
+		var named_near: int = nearly if nearly > 0 else nearly_hidden
+		var holding: String = "names contain" if named_near > 1 else "name contains"
+		(
+			notes
+			. append(
+				(
+					'name is matched as a glob against the whole name; %d %snode %s "%s", which "*%s*"%s would find'
+					% [
+						named_near,
+						"" if nearly > 0 else "hidden ",
+						holding,
+						wanted["name"],
+						wanted["name"],
+						"" if nearly > 0 else " with includeHidden true",
+					]
+				)
 			)
 		)
-	if found.is_empty() and nearly_said > 0:
+	if found.is_empty() and nearly_said + nearly_said_hidden > 0:
+		var said_near: int = nearly_said if nearly_said > 0 else nearly_said_hidden
 		(
 			notes
 			. append(
 				(
-					'says with a wildcard is matched as a glob against a node\'s whole text; "%s" would find %d node%s'
-					% [widened_says, nearly_said, "" if nearly_said == 1 else "s"]
+					'says with a wildcard is matched as a glob against a node\'s whole text; "%s"%s would find %d %snode%s'
+					% [
+						widened_says,
+						"" if nearly_said > 0 else " with includeHidden true",
+						said_near,
+						"" if nearly_said > 0 else "hidden ",
+						"" if said_near == 1 else "s",
+					]
 				)
 			)
 		)
@@ -183,17 +220,52 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	return answer
 
 
-## Whether the player can see [param node], its ancestors counted.
+## Whether the player can see [param node], by the rule the engine draws by.
 ##
-## Not [method CanvasItem.is_visible_in_tree] on its own, because only the nodes that draw have it:
-## a plain Node sitting between a hidden panel and a label has no visibility to ask about, and the
-## label answers that it is visible while nothing of it is on screen. Walking up is what makes a
-## row hidden because the panel holding it is hidden, which is what somebody checking a screen is
-## asking about. A wait on words asks the same, so it reads this too.
+## A CanvasItem's visibility comes down through CanvasItem parents only, and one whose parent is not
+## a CanvasItem starts again from its canvas: measured on 4.7.2, a Label under a plain Node under a
+## hidden panel, and one under a hidden Node3D, both answer visible in tree, while one straight under
+## the panel does not. Walking every ancestor called those two hidden, so their words were left off
+## a screen that showed them and a wait on them ran out. What a CanvasItem's rule leaves out is its
+## canvas: a hidden layer hides everything drawn on it while each item keeps its own flag, and a
+## hidden window everything in it. A wait on words asks the same, so it reads this too.
 static func shown(node: Node) -> bool:
+	var item: CanvasItem = node as CanvasItem
+	if item != null:
+		return item.is_visible_in_tree() and _on_a_shown_canvas(item)
+	var spatial: Node3D = node as Node3D
+	if spatial != null:
+		return spatial.is_visible_in_tree() and _in_shown_windows(spatial)
+	var layer: CanvasLayer = node as CanvasLayer
+	if layer != null:
+		return layer.visible and _in_shown_windows(layer)
+	var window: Window = node as Window
+	if window != null:
+		return window.visible and _in_shown_windows(window.get_parent())
+	# A node that draws nothing is shown when what it sits in is.
+	var parent: Node = node.get_parent()
+	return parent == null or shown(parent)
+
+
+## Whether the canvas [param item] is drawn on is showing: its layer, and the windows around it.
+static func _on_a_shown_canvas(item: CanvasItem) -> bool:
+	var walk: Node = item.get_parent()
+	while walk != null:
+		var layer: CanvasLayer = walk as CanvasLayer
+		if layer != null:
+			return layer.visible and _in_shown_windows(layer)
+		if walk is Viewport:
+			return _in_shown_windows(walk)
+		walk = walk.get_parent()
+	return true
+
+
+## Whether every window [param node] sits in is showing, itself included when it is one.
+static func _in_shown_windows(node: Node) -> bool:
 	var walk: Node = node
 	while walk != null:
-		if not _drawn(walk):
+		var window: Window = walk as Window
+		if window != null and not window.visible:
 			return false
 		walk = walk.get_parent()
 	return true
@@ -303,7 +375,11 @@ static func _script_is(attached: Script, wanted: String) -> bool:
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
 	var include_hidden: bool = Read.as_bool(params.get("include_hidden", false))
-	var limit: int = clampi(Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT), 1, READ_LIMIT)
+	var limit: int = Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT)
+	if limit < 1 or limit > LIMIT_CEILING:
+		return {
+			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
+		}
 
 	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
@@ -337,36 +413,22 @@ func read_text(params: Dictionary) -> Dictionary:
 ## until it is opened, and reading a closed menu would put every item on the screen.
 ## Fills [param into] up to [param most] lines and answers with how many further lines the rest of
 ## the subtree says, which is what the caller is told rather than left to infer.
+##
+## Asked of each node rather than cut off at the first hidden one, since a hidden panel does not
+## hide a label reached through a plain Node: see [method shown].
 func _read_into(node: Node, include_hidden: bool, most: int, into: Array[String]) -> int:
-	if not include_hidden and not _drawn(node):
-		return 0
 	var left_out: int = 0
-	for said: String in Words.lines_said_by(node):
-		if into.size() < most:
-			into.append(said)
-		else:
-			left_out += 1
+	if include_hidden or shown(node):
+		for said: String in Words.lines_said_by(node):
+			if into.size() < most:
+				into.append(said)
+			else:
+				left_out += 1
 	for child: Node in node.get_children(true):
 		left_out += _read_into(child, include_hidden, most, into)
 	return left_out
 
 
-## Whether [param node] is on the screen at all, for the three kinds of thing that can be hidden.
-##
-## A Node3D among them because a hidden one draws nothing, Label3D included: reading a screen or
-## finding what is on it counted a hidden 3D subtree as showing, which is the one answer neither
-## question wants.
-static func _drawn(node: Node) -> bool:
-	var control: CanvasItem = node as CanvasItem
-	if control != null:
-		return control.visible
-	var spatial: Node3D = node as Node3D
-	if spatial != null:
-		return spatial.visible
-	var window: Window = node as Window
-	return window == null or window.visible
-
-
 ## Where a node is on screen: a Control's rectangle, a Node2D's position, or the place a 3D node
 ## is drawn in, in both the canvas coordinates the node reports and the window pixels input
 ## arrives in. The two differ whenever the project stretches its viewport, which is what made a
@@ -562,304 +624,6 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
-func set_property(params: Dictionary) -> Dictionary:
-	var node_path: String = str(params.get("path", ""))
-	var property: String = str(params.get("property", ""))
-	var value: Variant = params.get("value")
-
-	if node_path.is_empty() or property.is_empty():
-		return {"type": "error", "message": "Node path and property required"}
-
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
-	if standing.has("message"):
-		return standing
-	var node: Node = standing["node"]
-
-	# Through a path as well, for the reason [method Paths.walk_to] gives, and read back off the same
-	# holder afterwards: a set that does not take says so by answering with the old value, which is
-	# how a typed container refusing a write is told from one accepting it.
-	var reached: Dictionary = Paths.walk_to(node, node_path, property)
-	if reached.has("message"):
-		return reached
-
-	var holder: Variant = reached["holder"]
-	var named: String = reached["name"]
-	# A call can be walked through and read, and is not a place: what it returns is the method's
-	# to hand out, and writing "into" it would set nothing the game keeps.
-	if not Paths.method_of(named).is_empty():
-		return {
-			"type": "error",
-			"message":
-			(
-				"%s:%s is a call, and a call is not a place to write: name a property"
-				% [reached["called"], named]
-			)
-		}
-	if not Paths.can_read(holder, named):
-		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
-	var old_value: Variant = Paths.read_under(holder, named)
-	# The same rule the call path holds: a value that cannot become what the property holds is
-	# refused rather than written. Writing it means the engine picks something, and what it picks
-	# for a word where a number goes is zero, which the answer then reports as the new value.
-	var slot: Dictionary = Values.slot_declared(holder, named)
-	var wanted: int = slot["type"] if slot["type"] != TYPE_NIL else typeof(old_value)
-	var given: Variant
-	if wanted == TYPE_OBJECT and (value is String or value is Dictionary):
-		var named_object: Dictionary = _object_named(node, node_path, value, str(slot["class"]))
-		if named_object.has("message"):
-			return {
-				"type": "error",
-				"message": "%s.%s holds an object: %s" % [reached["called"], named, named_object["message"]]
-			}
-		given = named_object["object"]
-	else:
-		given = _values.fitted(value, wanted)
-		if not Values.acceptable(given, wanted):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s holds %s and the value given is %s, which cannot become one."
-					% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
-				)
-			}
-		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
-		if typed.has("message"):
-			return {
-				"type": "error",
-				"message":
-				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
-			}
-		given = typed["value"]
-	# The write alone, setter included, which is where a property's cost is.
-	var began: int = Time.get_ticks_usec()
-	Paths.write(holder, named, given)
-	var elapsed: int = Time.get_ticks_usec() - began
-	var now: Variant = Paths.read_under(holder, named)
-	# Read back rather than trusted. The engine drops a write it will not take without a word, and
-	# the answer then showed the old value as the new one, shaped as a success: a typed container
-	# refusing a plain list did exactly that. A value the property changed on the way in, a setter
-	# clamping it, still changed it, so only a write that left the property as it was is refused.
-	# And only one that asked for a change: the value the property already held, written again, left
-	# it as it was because nothing was asked of it.
-	var already: bool = _held_already(given, old_value)
-	if (
-		Values.comparable(given, old_value)
-		and not already
-		and Values.comparable(now, old_value)
-		and now == old_value
-	):
-		return {
-			"type": "error",
-			"message":
-			(
-				(
-					"%s.%s was given %s and still holds %s: the engine kept what it had,"
-					+ " which a property it will not write does."
-				)
-				% [
-					reached["called"],
-					named,
-					JSON.stringify(_values.serialize(given)),
-					JSON.stringify(_values.serialize(now))
-				]
-			)
-		}
-
-	var answer: Dictionary = {
-		"type": "property_set",
-		"path": node_path,
-		"property": property,
-		"old_value": _values.serialize(old_value),
-		"new_value": _values.serialize(now),
-		"elapsed_usec": elapsed
-	}
-	if already and Values.comparable(now, old_value) and now == old_value:
-		answer["unchanged"] = true
-	return answer
-
-
-## Whether [param given] is the value [param held] already is, at the precision the property keeps.
-##
-## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
-## reads back as -1.10000002384186, so comparing the two exactly took a write of the value already
-## held for one the engine refused (#780). Rounding both to 32 bits is exact for a 32-bit property.
-## A 64-bit one can take a write this calls the same and read back changed, and the caller calls a
-## write unchanged only when it reads back as it was. What that cannot tell apart is a 64-bit
-## property whose setter ignored a value differing from the held one below 32 bits: it is answered
-## unchanged rather than refused. Vectors and colours hold 32-bit parts in the value itself, so they
-## already compare at the property's precision.
-static func _held_already(given: Variant, held: Variant) -> bool:
-	if not Values.comparable(given, held):
-		return false
-	if given == held:
-		return true
-	if typeof(given) != TYPE_FLOAT or typeof(held) != TYPE_FLOAT:
-		return false
-	return PackedFloat32Array([given])[0] == PackedFloat32Array([held])[0]
-
-
-func call_method(params: Dictionary) -> Dictionary:
-	var node_path: String = str(params.get("path", ""))
-	var method: String = str(params.get("method", ""))
-	var args: Array = params.get("args", [])
-
-	if node_path.is_empty() or method.is_empty():
-		return {"type": "error", "message": "Node path and method required"}
-
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
-	if standing.has("message"):
-		return standing
-	var node: Node = standing["node"]
-
-	# Through a path as well, for the reason [method Paths.walk_to] gives. What a game does hangs off its
-	# nodes as much as its state does, so reading `_game:run:day` while being unable to call
-	# `_game:run:advance` answers half of what a node holds and refuses the other half.
-	var reached: Dictionary = Paths.walk_to(node, node_path, method)
-	if reached.has("message"):
-		return reached
-
-	# A list or a map answers the calls a path makes on one, and nothing else: said in those terms
-	# rather than as "has no method", which reads as a misspelling of a method that was never going
-	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
-	if not reached["holder"] is Object:
-		var sort: String = "a list"
-		if reached["holder"] is Dictionary:
-			sort = "a map"
-		elif Paths.packed(reached["holder"]):
-			sort = "a packed list"
-		var spelled: String = str(reached["name"])
-		if Paths.method_of(spelled).is_empty():
-			spelled += "()"
-		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
-			var read_from: int = Time.get_ticks_usec()
-			var answered: Variant = Paths.read_under(reached["holder"], spelled)
-			var read_for: int = Time.get_ticks_usec() - read_from
-			return {
-				"type": "method_result",
-				"path": node_path,
-				"method": method,
-				"result": _values.serialize(answered),
-				"elapsed_usec": read_for,
-			}
-		var why: String = (
-			"%s:%s takes no arguments" % [reached["called"], spelled]
-			if Paths.can_read(reached["holder"], spelled)
-			else Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
-		)
-		return {
-			"type": "error",
-			"message":
-			(
-				"%s. A method of what %s holds is called on the element, as in %s:0:%s"
-				% [why, sort, reached["called"], reached["name"]]
-			)
-		}
-	var holder: Object = reached["holder"]
-	var named: String = reached["name"]
-	# The method a call ends on is the one being called whether or not it carries the brackets a
-	# step along the way would: "get_viewport():gui_get_focus_owner()" is the same call as without
-	# the last pair.
-	if not Paths.method_of(named).is_empty():
-		named = Paths.method_of(named)
-	if not holder.has_method(named):
-		return {"type": "error", "message": "%s has no method %s" % [reached["called"], named]}
-
-	# Checked before the call rather than left to it. `callv` raises inside the game when an
-	# argument cannot be converted, and an error raised in a game somebody is playing holds it at a
-	# debugger break: every later call then reports a game that is not responding, which points
-	# nowhere near the argument. A wrong argument costs a refusal, never the session's game.
-	var deserialized_args: Array = []
-	for index: int in args.size():
-		var wants: int = _values.parameter_type(holder, named, index)
-		if wants == TYPE_OBJECT and (args[index] is String or args[index] is Dictionary):
-			var declared: String = _values.parameter_class(holder, named, index)
-			var named_object: Dictionary = _object_named(node, node_path, args[index], declared)
-			if named_object.has("message"):
-				return {
-					"type": "error",
-					"message":
-					"%s.%s argument %d: %s" % [reached["called"], named, index + 1, named_object["message"]]
-				}
-			deserialized_args.append(named_object["object"])
-			continue
-		var given: Variant = _values.fitted(args[index], wants)
-		if not Values.acceptable(given, wants):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted."
-					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
-				)
-			}
-		# A typed list or map is built as one, since a plain one handed to such a parameter raises
-		# inside the game, which is what every check here exists to stop.
-		var container: Variant = _values.parameter_container(holder, named, index)
-		if container != null:
-			var typed: Dictionary = _values.typed_like(
-				given, container, _element_object.bind(node, node_path)
-			)
-			if typed.has("message"):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s takes a typed %s as argument %d: %s."
-						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
-					)
-				}
-			given = typed["value"]
-		deserialized_args.append(given)
-
-	# Timed around the call alone, since the bridge's round trip is a second or more and swamps what
-	# one click's work costs; the frame metrics read whichever frame is last, which is not this one.
-	var began: int = Time.get_ticks_usec()
-	var result: Variant = holder.callv(named, deserialized_args)
-	var elapsed: int = Time.get_ticks_usec() - began
-
-	return {
-		"type": "method_result",
-		"path": node_path,
-		"method": method,
-		"result": _values.serialize(result),
-		"elapsed_usec": elapsed
-	}
-
-
-## [method _object_named] with the path first, which is the order [method Values.typed_like] calls
-## an element resolver in.
-func _element_object(given: Variant, declared: String, node: Node, node_path: String) -> Dictionary:
-	return _object_named(node, node_path, given, declared)
-
-
-## "list" or "map", for a refusal about a typed container.
-static func _sort_of(container: Variant) -> String:
-	return "list" if container is Array else "map"
-
-
-## The object [param given] names for a slot or a parameter declared as [param declared], as
-## `{"object": ...}`, or `{"message": ...}` saying why it names none that fits.
-##
-## JSON cannot carry an object, so one the game holds is named by its path, read from the node the
-## call or the write was made on, and handed over as that instance rather than a copy: a method
-## given a piece of the game's state acts on the piece the game keeps, and a slot written with one
-## holds the game's own.
-##
-## The text null names no object, which is what an object slot or parameter takes to be emptied. A
-## caller's null arrived as that text in #772 and #783, and was looked up as a node called "null".
-func _object_named(node: Node, node_path: String, given: Variant, declared: String) -> Dictionary:
-	if given is String and str(given).strip_edges() == "null":
-		return {"object": null}
-	var found: Dictionary = Paths.object_at(_host.get_tree().root, node, node_path, given)
-	if found.has("message"):
-		return found
-	var instance: Object = found["object"]
-	if not declared.is_empty() and not Values.is_a(instance, declared):
-		return {"message": "%s is %s, not a %s" % [str(given), Values.class_of(instance), declared]}
-	return found
-
-
 func get_metrics(params: Dictionary) -> Dictionary:
 	var metrics: Array = params.get("metrics", [])
 	var all: Dictionary = {

package/build/godot/addons/gdharness_runtime/runtime_screen.gd

@@ -17,20 +17,32 @@ extends RefCounted
 ## sit inside another viewport. A SubViewport drawn some other way, onto a mesh for one, has no
 ## place on the screen to carry the point to, and the point stays in it.
 static func reach(viewport: Viewport, point: Vector2) -> Dictionary:
+	var out: Array[Dictionary] = steps_out(viewport, point)
+	return out.back()
+
+
+## Every viewport a pointer at [param point] in [param viewport] passes through on the way out to
+## the one it arrives at, innermost first, as {"viewport", "point", "through"}: the point in that
+## viewport's space, and the embedded [Window] or the [SubViewportContainer] in it that shows the
+## step before, null for the first. What [method reach] answers is the last of them.
+static func steps_out(viewport: Viewport, point: Vector2) -> Array[Dictionary]:
+	var out: Array[Dictionary] = [{"viewport": viewport, "point": point, "through": null}]
 	while true:
 		var window: Window = viewport as Window
 		if window != null and window.is_embedded() and window.get_parent() != null:
 			point += Vector2(window.position)
 			viewport = window.get_parent().get_viewport()
+			out.append({"viewport": viewport, "point": point, "through": window})
 			continue
 		var shown_by: SubViewportContainer = viewport.get_parent() as SubViewportContainer
 		if viewport is SubViewport and shown_by != null:
 			var scaled: Vector2 = point * float(shown_by.stretch_shrink) if shown_by.stretch else point
 			point = shown_by.get_global_transform_with_canvas() * scaled
 			viewport = shown_by.get_viewport()
+			out.append({"viewport": viewport, "point": point, "through": shown_by})
 			continue
 		break
-	return {"viewport": viewport, "point": point}
+	return out
 
 
 ## Where [param point], in [param viewport]'s own coordinates, is in the pixels of the window the