/// <summary>
/// Finds the nearest object that can be snapped to and adds a new HandGrabInteractable to
/// it with the user hand representation.
/// </summary>
public void RecordPose()
{
if (_handGrabInteractor == null ||
_handGrabInteractor.Hand == null)
{
Debug.LogError("Missing HandGrabInteractor. Ensure you are in PLAY mode!", this);
return;
}
if (_recordable == null)
{
Debug.LogError("Missing Recordable", this);
return;
}
HandPose trackedHandPose = TrackedPose();
if (trackedHandPose == null)
{
Debug.LogError("Tracked Pose could not be retrieved", this);
return;
}
Pose gripPoint = _recordable.transform.RelativeOffset(_handGrabInteractor.transform);
HandGrabPoint point = AddHandGrabPoint(trackedHandPose, gripPoint);
AttachGhost(point);
}
/// <summary>
/// Generates a new HandGrabPointData that mirrors the provided one. Left hand becomes right hand and vice-versa.
/// The mirror axis is defined by the surface of the snap point, if any, if none a best-guess is provided
/// but note that it can then moved manually in the editor.
/// </summary>
/// <param name="originalPoint">The point to mirror</param>
/// <param name="originalPoint">The target HandGrabPoint to set as mirrored of the originalPoint</param>
public static void MirrorHandGrabPoint(HandGrabPoint originalPoint, HandGrabPoint mirrorPoint)
{
HandPose handPose = originalPoint.HandPose;
Handedness oppositeHandedness = handPose.Handedness == Handedness.Left ? Handedness.Right : Handedness.Left;
HandGrabPointData mirrorData = originalPoint.SaveData();
mirrorData.handPose.Handedness = oppositeHandedness;
if (originalPoint.SnapSurface != null)
{
mirrorData.gripPose = originalPoint.SnapSurface.MirrorPose(mirrorData.gripPose);
}
else
{
mirrorData.gripPose = mirrorData.gripPose.MirrorPoseRotation(Vector3.forward, Vector3.up);
Vector3 translation = Vector3.Project(mirrorData.gripPose.position, Vector3.right);
mirrorData.gripPose.position = mirrorData.gripPose.position - 2f * translation;
}
mirrorPoint.LoadData(mirrorData, originalPoint.RelativeTo);
if (originalPoint.SnapSurface != null)
{
SnapSurfaces.ISnapSurface mirroredSurface = originalPoint.SnapSurface.CreateMirroredSurface(mirrorPoint.gameObject);
mirrorPoint.InjectOptionalSurface(mirroredSurface);
}
}
private void AttachGhost(HandGrabPoint point)
{
if (_ghostProvider != null)
{
HandGhost ghostPrefab = _ghostProvider.GetHand(_handGrabInteractor.Hand.Handedness);
HandGhost ghost = GameObject.Instantiate(ghostPrefab, point.transform);
ghost.SetPose(point);
}
}
public static void CloneHandGrabPoint(HandGrabPoint originalPoint, HandGrabPoint targetPoint)
{
HandGrabPointData mirrorData = originalPoint.SaveData();
targetPoint.LoadData(mirrorData, originalPoint.RelativeTo);
if (originalPoint.SnapSurface != null)
{
SnapSurfaces.ISnapSurface mirroredSurface = originalPoint.SnapSurface.CreateDuplicatedSurface(targetPoint.gameObject);
targetPoint.InjectOptionalSurface(mirroredSurface);
}
}
/// <summary>
/// Relay to the Puppet to set the ghost hand to the desired static pose
/// </summary>
/// <param name="handGrabPoint">The point to read the HandPose from</param>
public void SetPose(HandGrabPoint handGrabPoint)
{
HandPose userPose = handGrabPoint.HandPose;
if (userPose == null)
{
return;
}
Transform relativeTo = handGrabPoint.RelativeTo;
_puppet.SetJointRotations(userPose.JointRotations);
SetGripPose(handGrabPoint.RelativeGrip, relativeTo);
}
private void AddHandGrabPoint(HandGrabPoint copy = null, float?scale = null)
{
HandGrabPoint point = _interactable.CreatePoint();
if (copy != null)
{
HandGrabPointEditor.CloneHandGrabPoint(copy, point);
if (scale.HasValue)
{
HandGrabPointData scaledData = point.SaveData();
scaledData.scale = scale.Value;
point.LoadData(scaledData, copy.RelativeTo);
}
}
_interactable.GrabPoints.Add(point);
}
protected virtual void OnValidate()
{
if (_puppet == null ||
_gripPoint == null)
{
return;
}
if (_handGrabPoint == null)
{
HandGrabPoint point = this.GetComponentInParent <HandGrabPoint>();
if (point != null)
{
SetPose(point);
}
}
else if (_handGrabPoint != null)
{
SetPose(_handGrabPoint);
}
}
private void DrawGenerationMenu()
{
if (GUILayout.Button("Create Mirrored HandGrabInteractable"))
{
HandGrabInteractable mirrorInteractable =
HandGrabInteractable.Create(_interactable.RelativeTo,
$"{_interactable.gameObject.name}_mirror");
HandGrabInteractableData data = _interactable.SaveData();
data.points = null;
mirrorInteractable.LoadData(data);
foreach (HandGrabPoint point in _interactable.GrabPoints)
{
HandGrabPoint mirrorPoint = mirrorInteractable.CreatePoint();
HandGrabPointEditor.MirrorHandGrabPoint(point, mirrorPoint);
mirrorPoint.transform.SetParent(mirrorInteractable.transform);
mirrorInteractable.GrabPoints.Add(mirrorPoint);
}
}
}
protected virtual void Reset()
{
_puppet = this.GetComponent <HandPuppet>();
_handGrabPoint = this.GetComponentInParent <HandGrabPoint>();
}
public void InjectOptionalHandGrabPoint(HandGrabPoint handGrabPoint)
{
_handGrabPoint = handGrabPoint;
}
private void Awake()
{
_handGrabPoint = target as HandGrabPoint;
_handPoseProperty = serializedObject.FindProperty("_handPose");
AssignMissingGhostProvider();
}
