Make tracking local to model

Core/Main.gd

@@ -730,7 +730,7 @@ func reinit_mods():
 func get_audio():
 	return $AudioStreamRecord
 
-func get_controller():
+func get_controller() -> ModelController:
 	return $ModelController
 
 ## Get the saved user data directory. When running in the editor, this will be

Core/ModelController.gd

@@ -80,7 +80,7 @@ func get_skeleton() -> Skeleton3D:
 		return null
 
 	# Try to find the skeleton on the secondary object first.
-	var secondary = $Model.get_node("secondary")
+	var secondary = $Model.get_node_or_null("secondary")
 	if secondary:
 		if secondary is VRMSecondary:
 			var skeleton2 : Skeleton3D = secondary.get_node(secondary.skeleton)

Mods/Base/Mod_Base.gd

@@ -384,10 +384,14 @@ func get_skeleton() -> Skeleton3D:
 	#   applies to.
 	return get_app().get_skeleton()
 
+## Get the ModelController node.
+func get_model_controller() -> ModelController:
+	return get_app().get_controller()
+
 ## Get the VTuber model in the scene.
 func get_model() -> Node3D:
 	# FIXME (multiplayer): Return the specific model this applies to.
-	var controller = get_app().get_node("ModelController")
+	var controller = get_model_controller()
 	return controller.get_node_or_null("Model")
 
 func get_bone_transform(bone_name) -> Transform3D:

Mods/MediaPipe/MediaPipeController.gd

@@ -261,13 +261,16 @@ func scene_init():
 	last_parsed_data = {}
 
 	# Move hand "rest" trackers into the scene.
-	var root = get_skeleton().get_parent()
-	var left_rest = $LeftHandRestReference
-	var right_rest = $RightHandRestReference
-	remove_child(left_rest)
-	remove_child(right_rest)
-	root.add_child(left_rest)
-	root.add_child(right_rest)
+	#var root = get_skeleton().get_parent()
+	#var left_rest = $LeftHandRestReference
+	#var right_rest = $RightHandRestReference
+	#remove_child(left_rest)
+	#remove_child(right_rest)
+	#root.add_child(left_rest)
+	#root.add_child(right_rest)
+
+	# ^ Commented this stuff out to make it possible to
+	# move the model node around in global space
 
 	# Set the head tracker to match the model's head position.
 	var head_bone_index = get_skeleton().find_bone("Head")
@@ -287,14 +290,17 @@ func scene_shutdown():
 	udp_server.close()
 	udp_server = null
 
-	var root = get_skeleton().get_parent()
-	var left_rest = root.get_node("LeftHandRestReference")
-	var right_rest = root.get_node("RightHandRestReference")
+	#var root = get_skeleton().get_parent()
+	#var left_rest = root.get_node("LeftHandRestReference")
+	#var right_rest = root.get_node("RightHandRestReference")
+	#
+	#root.remove_child(left_rest)
+	#root.remove_child(right_rest)
+	#add_child(left_rest)
+	#add_child(right_rest)
 
-	root.remove_child(left_rest)
-	root.remove_child(right_rest)
-	add_child(left_rest)
-	add_child(right_rest)
+	# ^ Commented this out because I commented out the code that
+	# makes this a requirement.
 
 	# Reset pose and blendshapes.
 	get_app().get_controller().reset_skeleton_to_rest_pose()
@@ -1081,7 +1087,7 @@ func _update_hand_tracker(
 		# FIXME: Hardcoded values all over this part.
 		#
 		var chest_transform_global_pose = skel.get_bone_global_pose(skel.find_bone("Chest"))
-		var min_z = (skel.global_transform * chest_transform_global_pose).origin
+		var min_z = (skel.transform * chest_transform_global_pose).origin
 		if target_origin.z < min_z.z + 0.2:
 			target_origin.z = min_z.z + 0.2
 

Mods/ModelMovementTester/ModelMovementTester.gd

@@ -0,0 +1,41 @@
+extends Mod_Base
+class_name Mod_ModelMovementTester
+
+var test_movement := false
+
+var t := 0.0
+
+var movement_speed := 1.0
+
+func _ready() -> void:
+	add_tracked_setting(
+		"test_movement",
+		"Test Movement")
+	add_tracked_setting(
+		"movement_speed", "Movement Speed",
+		{ "min" : 0.1, "max" : 2.0 })
+
+func scene_shutdown() -> void:
+	var controller := get_model_controller()
+
+	# Throws errors when closing app
+	controller.global_transform.origin = Vector3.ZERO
+	controller.global_transform.basis = Basis.IDENTITY
+
+func _process(delta: float) -> void:
+	if test_movement:
+		test_model_movement(delta * movement_speed)
+
+## Use this to test 6 axes of model movement.
+func test_model_movement(delta: float) -> void:
+	var controller := get_model_controller()
+
+	t += delta
+	controller.global_transform.origin = Vector3(sin(t) * 0.5,
+												cos(t) * 0.5,
+												sin(t) * 0.5)
+	controller.global_transform.basis = Basis.IDENTITY.rotated(
+											Vector3(sin(t) * 2.0,
+													cos(t) * 2.0,
+													sin(t) * 2.0).normalized(),
+											PI/4.0)

Mods/ModelMovementTester/ModelMovementTester.gd.uid

@@ -0,0 +1 @@
+uid://chv81bhj12v5n

Mods/ModelMovementTester/ModelMovementTester.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3 uid="uid://bkc4rcnv5na3n"]
+
+[ext_resource type="Script" uid="uid://chv81bhj12v5n" path="res://Mods/ModelMovementTester/ModelMovementTester.gd" id="1_yike5"]
+
+[node name="ModelMovementTester" type="Node3D"]
+script = ExtResource("1_yike5")

Mods/ModelMovementTester/description.txt

@@ -0,0 +1 @@
+Moves and rotates the model for debugging purposes.

Mods/PoseIK/PoseIK.gd

@@ -212,10 +212,22 @@ func load_before(_settings_old : Dictionary, _settings_new : Dictionary):
 func _update_local_trackers() -> void:
 
 	var tracker_dict : Dictionary = get_global_mod_data("trackers")
-
-	$Head.global_transform = tracker_dict["head"].transform
-	$Hand_Left.global_transform = tracker_dict["hand_left"].transform
-	$Hand_Right.global_transform = tracker_dict["hand_right"].transform
+
+	var model = get_model()
+	var model_up: Vector3 = model.global_basis.y
+
+	# This takes the tracker_dict data and transforms the ik targets
+	# to be relative to the model node's global transform.
+	var new_head_basis: Basis = model.global_basis * tracker_dict["head"].transform.basis
+	var new_head_pos: Vector3 = (model.global_basis * tracker_dict["head"].transform.origin) + model.global_position
+	var new_hand_l_basis: Basis = model.global_basis * tracker_dict["hand_left"].transform.basis
+	var new_hand_l_pos: Vector3 = (model.global_basis * tracker_dict["hand_left"].transform.origin) + model.global_position
+	var new_hand_r_basis: Basis = model.global_basis * tracker_dict["hand_right"].transform.basis
+	var new_hand_r_pos: Vector3 = (model.global_basis * tracker_dict["hand_right"].transform.origin) + model.global_position
+
+	$Head.global_transform = Transform3D(new_head_basis, new_head_pos)
+	$Hand_Left.global_transform = Transform3D(new_hand_l_basis, new_hand_l_pos)
+	$Hand_Right.global_transform = Transform3D(new_hand_r_basis, new_hand_r_pos)
 
 	# https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker
 	var mediapipe_hand_landmark_names : Array = [
@@ -271,6 +283,7 @@ func _process(delta : float) -> void:
 	var tracker_dict : Dictionary = get_global_mod_data("trackers")
 	var skel : Skeleton3D = get_skeleton()
 	var model_root : Node3D = get_model()
+	var model_controller : ModelController = get_model_controller()
 
 	# ---------------------------------------------------------------------------------------------
 	# Update this mod's tracker instances
@@ -294,14 +307,19 @@ func _process(delta : float) -> void:
 
 	# FIXME: Hack.
 	# This just moves the body based on the head position.
-	var head_pos = $Head.transform.origin
-	var model_pos = model_root.transform.origin
+	var head_tracker_local: Vector3 = model_controller.to_local($Head.transform.origin)
+	var head_offset_global: Vector3 = model_root.global_basis * Vector3(
+																	0.0,
+																	head_vertical_offset,
+																	0.0
+																	)
+	var head_pos = head_tracker_local - model_root.position + head_offset_global
 
 	if true: # FIXME: ???????
-		model_root.transform.origin = model_pos.lerp(head_pos, delta * hip_adjustment_speed)
-		#model_root.transform.origin = head_pos
-		#model_root.transform.origin.y = model_y 
-		#model_root.transform.origin.y = lerp(model_pos.y, head_pos.y - 1.9, 0.01)
+		model_root.position = model_root.position.lerp(head_pos, delta * hip_adjustment_speed)
+		#model_root.position = head_pos
+		#model_root.position.y = model_y 
+		#model_root.position.y = lerp(model_head_effect.y, head_pos.y - 1.9, 0.01)
 
 		# FIXME: Another hack!
 		var head_rest_transform = get_skeleton().get_bone_global_rest(
@@ -310,8 +328,8 @@ func _process(delta : float) -> void:
 
 		# FIXME: Hard-coded fudge factor.
 		# FIXME: Why can't we just map this directly again? It looks like we're shrugging when the arms get set up wrong or something.
-		model_root.transform.origin.y = lerp(
-			model_pos.y, head_pos.y - head_rest_transform.origin.y + head_vertical_offset,
+		model_root.position.y = lerp(
+			model_root.position.y, head_pos.y - head_rest_transform.origin.y + head_vertical_offset,
 			clamp(hips_vertical_blend_speed * delta, 0.0, 1.0))
 
 	# ---------------------------------------------------------------------
@@ -322,7 +340,7 @@ func _process(delta : float) -> void:
 	var z_pole_dist = 10.0
 	var y_pole_dist = 5.0
 
-	for chain_name in ["arm_left", "arm_right"]:
+	for chain_name: String in ["arm_left", "arm_right"]:
 
 		var tracker_to_use = $Hand_Left
 		var compensation_alpha_scale = 1.0
@@ -332,11 +350,11 @@ func _process(delta : float) -> void:
 			compensation_alpha_scale *= -1.0
 			pole_target_x = -x_pole_dist
 
-		var tracker_local_position = \
-			skel.get_global_transform().inverse() * tracker_to_use.get_global_transform()
+		var tracker_local_transform = \
+			tracker_dict[chain_name.replace("arm", "hand")].transform
 		var base_bone_position = skel.get_bone_global_pose(
 			skel.find_bone(_ikchains_dict[chain_name].base_bone)).origin
-		#print(tracker_local_position.origin.x - bone_position.x)
+		#print(tracker_local_transform.origin.x - bone_position.x)
 
 		# See if we can raise the shoulders for when arms go too far up.
 		if chain_name == "arm_left" or chain_name == "arm_right":
@@ -357,28 +375,35 @@ func _process(delta : float) -> void:
 					var shoulder_pose = skel.get_bone_global_pose(shoulder_bone_index)
 					var chest_pose_inv = chest_pose.inverse()
 					var shoulder_y = (chest_pose_inv * shoulder_pose).origin.y
-					var tracker_local_chest = chest_pose_inv * tracker_local_position
+					var tracker_local_chest = chest_pose_inv * tracker_local_transform
 					if tracker_local_chest.origin.y > shoulder_y:
 						#print(tracker_local_chest.origin.y - shoulder_y)
-						skel.set_bone_pose_rotation(shoulder_bone_index,
-							Quaternion(Vector3(0.0, 0.0, 1.0), (tracker_local_chest.origin.y - shoulder_y) * 2.0 * rotation_scale) *
-							skel.get_bone_rest(shoulder_bone_index).basis.get_rotation_quaternion())
+						var shoulder_rest: Transform3D = skel.get_bone_rest(shoulder_bone_index)
+						var shoulder_rot_quat: Quaternion = shoulder_rest.basis.get_rotation_quaternion()
+						skel.set_bone_pose_rotation(
+								shoulder_bone_index,
+								Quaternion(
+									Vector3(0.0, 0.0, 1.0),
+									(tracker_local_chest.origin.y - shoulder_y)
+										* 2.0
+										* rotation_scale)
+										* shoulder_rot_quat)
 
 		var pole_target_y = -y_pole_dist
 		var pole_target_z = -z_pole_dist
 
 		# Rotate pole target upwards when the arm reaches across the
 		# chest.
-		if (tracker_local_position.origin.x - base_bone_position.x) * compensation_alpha_scale < 0:
-			var alpha = -(tracker_local_position.origin.x - base_bone_position.x) * 3.0 * compensation_alpha_scale
+		if (tracker_local_transform.origin.x - base_bone_position.x) * compensation_alpha_scale < 0:
+			var alpha = -(tracker_local_transform.origin.x - base_bone_position.x) * 3.0 * compensation_alpha_scale
 			#print(alpha)
 			pole_target_y = lerp(-y_pole_dist, 0.0, alpha)
 			pole_target_z = lerp(-z_pole_dist, 0.0, alpha)
 
 		# Move pole target backwards when the arm is lowered.
 		#
 		# FIXME: Hardcoded values.
-		var arm_below_factor = (tracker_local_position.origin.y - base_bone_position.y) + 0.25
+		var arm_below_factor = (tracker_local_transform.origin.y - base_bone_position.y) + 0.25
 		arm_below_factor *= 1.0
 		if arm_below_factor < 0.0:
 			var alpha = arm_below_factor
@@ -403,9 +428,10 @@ func _process(delta : float) -> void:
 	# ---------------------------------------------------------------------------------------------
 	# Handle Leaning
 
-	var lean_check_axis : Vector3 = (skel.transform * skel.get_bone_global_pose(skel.find_bone("Hips"))).basis * Vector3(1.0, 0.0, 0.0)
+	var lean_check_axis : Vector3 = (skel.get_bone_global_pose(
+												skel.find_bone("Hips"))).basis.x
 	lean_check_axis = lean_check_axis.normalized()
-	var head_offset : Vector3 = tracker_dict["head"]["transform"].origin - model_root.transform.origin
+	var head_offset : Vector3 = tracker_dict["head"]["transform"].origin
 	var lean_amount : float = sin(lean_check_axis.dot(head_offset))
 	handle_lean(skel, lean_amount * lean_scale)