/// <summary> Checks whether the humanoid has an HeadTargetand adds one if none has been found</summary>
/// <param name="humanoid">The humanoid to check</param>
public static void DetermineTarget(HumanoidControl humanoid)
{
HeadTarget headTarget = humanoid.headTarget;
if (headTarget == null)
{
Transform headTargetTransform = humanoid.targetsRig.GetBoneTransform(HumanBodyBones.Head);
if (headTargetTransform == null)
{
Debug.LogError("Could not find head bone in targets rig");
return;
}
headTarget = headTargetTransform.GetComponent <HeadTarget>();
if (headTarget == null)
{
headTarget = headTargetTransform.gameObject.AddComponent <HeadTarget>();
headTarget.humanoid = humanoid;
//headTarget.RetrieveBones();
//headTarget.InitAvatar();
//headTarget.MatchTargetsToAvatar();
}
humanoid.headTarget = headTarget;
}
humanoid.headTarget = headTarget;
}
static public SphereCollider AddHeadCollider(GameObject headObject)
{
HeadTarget headTarget = headObject.GetComponent <HeadTarget>();
if (headTarget.headRigidbody == null)
{
headTarget.headRigidbody = headObject.AddComponent <Rigidbody>();
if (headTarget.headRigidbody != null)
{
headTarget.headRigidbody.mass = 1;
headTarget.headRigidbody.useGravity = false;
headTarget.headRigidbody.isKinematic = true;
}
}
SphereCollider collider = headObject.AddComponent <SphereCollider>();
if (collider != null)
{
collider.isTrigger = true;
collider.radius = 0.1F;
collider.center = new Vector3(0, 0, 0.05F);
}
return(collider);
}
// Do not remove this, this is dynamically called from Target_Editor!
// Changes the target transform used for this head target
// Generates a new headtarget component, so parameters will be lost if transform is changed
public static HeadTarget SetTarget(HumanoidControl humanoid, Transform targetTransform)
{
HeadTarget currentHeadTarget = humanoid.headTarget;
if (targetTransform == currentHeadTarget.transform)
{
return(currentHeadTarget);
}
RemoveFirstPersonCamara(currentHeadTarget);
GetDefaultHead(humanoid.targetsRig, ref targetTransform);
if (targetTransform == null)
{
return(currentHeadTarget);
}
HeadTarget headTarget = targetTransform.GetComponent <HeadTarget>();
if (headTarget == null)
{
headTarget = targetTransform.gameObject.AddComponent <HeadTarget>();
}
headTarget.NewComponent(humanoid);
headTarget.InitComponent();
return(headTarget);
}
public void InitController(SerializedProperty sensorProp, HeadTarget target)
{
if (sensorProp == null)
{
return;
}
Init(target);
SerializedProperty sensorTransformProp = sensorProp.FindPropertyRelative("sensorTransform");
sensorTransformProp.objectReferenceValue = sensorTransform;
SerializedProperty targetProp = sensorProp.FindPropertyRelative("target");
targetProp.objectReferenceValue = base.target;
if (!tracker.enabled || !enabled)
{
return;
}
CheckSensorTransform();
ShowSensor(target.humanoid.showRealObjects && target.showRealObjects);
SerializedProperty sensor2TargetPositionProp = sensorProp.FindPropertyRelative("sensor2TargetPosition");
sensor2TargetPositionProp.vector3Value = sensor2TargetPosition;
SerializedProperty sensor2TargetRotationProp = sensorProp.FindPropertyRelative("sensor2TargetRotation");
sensor2TargetRotationProp.quaternionValue = sensor2TargetRotation;
}
public static Camera AddCamera(HeadTarget headTarget) {
Camera camera = headTarget.transform.GetComponentInChildren<Camera>();
if (camera == null) {
Vector3 eyePosition = headTarget.GetEyePosition();
GameObject cameraObj = new GameObject("First Person Camera");
camera = cameraObj.AddComponent<Camera>();
camera.tag = "MainCamera";
camera.nearClipPlane = 0.1F;
headTarget.unityVRHead.cameraTransform = camera.transform;
camera.transform.SetParent(headTarget.transform, false);
camera.transform.position = eyePosition;
//if (headTarget.humanoid != null)
camera.transform.rotation = Quaternion.Euler(0, headTarget.humanoid.hipsTarget.hips.target.transform.eulerAngles.y, 0);
//else
// camera.transform.rotation = Quaternion.Euler(0, headTarget.iControl.transform.eulerAngles.y, 0);
cameraObj.AddComponent<AudioListener>();
}
if (headTarget.collisionFader)
AddScreenFader(camera);
else
RemoveScreenFader(camera.transform);
return camera;
}
private void UpdateHipsRotation()
{
HeadTarget headTarget = hipsTarget.humanoid.headTarget;
HandTarget leftHandTarget = hipsTarget.humanoid.leftHandTarget;
HandTarget rightHandTarget = hipsTarget.humanoid.rightHandTarget;
if (hipsTarget.hips.target.confidence.rotation < 0.5F)
{
Quaternion hipsTargetRotation = hipsTarget.hips.target.transform.rotation;
Quaternion headTargetRotation = headTarget.head.target.transform.rotation;
Vector3 neckTargetPosition = headTarget.neck.target.transform.position;
// still need to add foot based rotation
if (!(bodyRotation == BodyRotation.HeadRotation) &&
(leftHandTarget.hand.target.confidence.rotation > 0.5F && rightHandTarget.hand.target.confidence.rotation > 0.5F))
{
Quaternion newHipsRotation = TorsoMovements.CalculateHipsRotation(hipsTarget.hips.target.transform.position, hipsTargetRotation, leftHandTarget.transform.rotation, rightHandTarget.transform.rotation, hipsTarget.humanoid.leftFootTarget.transform, hipsTarget.humanoid.rightFootTarget.transform, headTargetRotation, neckTargetPosition);
hipsTarget.hips.target.transform.rotation = newHipsRotation;
}
else
{
Vector3 hipsUpDirection = hipsTarget.humanoid.up;
// We need to rotate the head to the up direction to reliably determine the head forward direction
Quaternion headBoneRotation = headTarget.head.bone.targetRotation;
Quaternion rotationToUp = Quaternion.FromToRotation(headBoneRotation * Vector3.up, hipsTarget.humanoid.up);
Vector3 hipsBackDirection = -(rotationToUp * headBoneRotation * Vector3.forward);
Quaternion q = Quaternion.LookRotation(hipsUpDirection, hipsBackDirection);
Quaternion hipRotation = q * Quaternion.Euler(90, 0, 0);
hipsTarget.hips.target.transform.rotation = hipRotation;
}
}
hipsTarget.hips.target.confidence.rotation = 0.2F;
}
// Do not remove this, this is dynamically called from Target_Editor!
public static HeadTarget CreateTarget(HumanoidTarget oldTarget)
{
GameObject targetObject = new GameObject("Head Target");
Transform targetTransform = targetObject.transform;
HumanoidControl humanoid = oldTarget.humanoid;
RemoveFirstPersonCamara((HeadTarget)oldTarget);
targetTransform.parent = oldTarget.humanoid.transform;
targetTransform.position = oldTarget.transform.position;
targetTransform.rotation = oldTarget.transform.rotation;
HeadTarget headTarget = targetTransform.gameObject.AddComponent <HeadTarget>();
headTarget.humanoid = humanoid;
humanoid.headTarget = headTarget;
#if hFACE
headTarget.face.headTarget = headTarget;
#endif
headTarget.RetrieveBones();
headTarget.InitAvatar();
headTarget.MatchTargetsToAvatar();
return(headTarget);
}
public static void ConfigurationInspector(FaceTarget faceTarget)
{
HumanoidControl humanoid = faceTarget.headTarget.humanoid;
SkinnedMeshRenderer[] avatarMeshes = HeadTarget.FindAvatarMeshes(humanoid);
string[] avatarMeshNames = HeadTarget.DistillAvatarMeshNames(avatarMeshes);
int meshWithBlendshapes = HeadTarget.FindBlendshapemesh(avatarMeshes, faceTarget.headTarget.smRenderer);//HeadTarget.FindMeshWithBlendshapes(avatarMeshes);
meshWithBlendshapes = EditorGUILayout.Popup("Head Mesh", meshWithBlendshapes, avatarMeshNames);
string[] blendshapes;
if (meshWithBlendshapes < avatarMeshes.Length)
{
faceTarget.headTarget.smRenderer = avatarMeshes[meshWithBlendshapes];
blendshapes = HeadTarget.GetBlendshapes(avatarMeshes[meshWithBlendshapes]);
}
else
{
blendshapes = new string[0];
}
EyeBrowsInspector(faceTarget);
EyesInspector(faceTarget, blendshapes);
CheeksInspector(faceTarget);
NoseInspector(faceTarget);
MouthInspector(faceTarget.mouth);
faceTarget.jaw.bone.transform = (Transform)EditorGUILayout.ObjectField("Jaw", faceTarget.jaw.bone.transform, typeof(Transform), true);
}
public static void OnEnable(SerializedObject serializedObject, HeadTarget headTarget)
{
leftEyeBlinkProp = serializedObject.FindProperty("face.leftEye.blink");
rightEyeBlinkProp = serializedObject.FindProperty("face.rightEye.blink");
InitExpressions(headTarget.face);
}
public TargetedNeckBone(HeadTarget headTarget)
{
this.headTarget = headTarget;
boneId = Bone.Neck;
bone.minAngles = minNeckAngles;
bone.maxAngles = maxNeckAngles;
}
public override void Init(HeadTarget headTarget)
{
base.Init(headTarget);
if (headTarget.humanoid != null)
{
tracker = headTarget.humanoid.mixedReality;
}
}
public override void Init(HeadTarget headTarget)
{
base.Init(headTarget);
if (headTarget.humanoid != null)
{
tracker = headTarget.humanoid.oculus;
}
}
private void SettingsInspector(HeadTarget headTarget)
{
//showSettings = EditorGUILayout.Foldout(showSettings, "Settings", true);
//if (showSettings) {
// EditorGUI.indentLevel++;
// //headTarget.jointLimitations = EditorGUILayout.Toggle("Joint Limitations", headTarget.jointLimitations);
// EditorGUI.indentLevel--;
//}
}
public override void Init(HeadTarget _headTarget)
{
base.Init(_headTarget);
if (headTarget.humanoid != null)
{
optitrackTracker = headTarget.humanoid.optitrack;
tracker = optitrackTracker;
}
}
public static Camera CheckCamera(HeadTarget headTarget) {
if (headTarget.unityVRHead.enabled) {
return AddCamera(headTarget);
}
else {
RemoveCamera(headTarget);
return null;
}
}
private static void UpdateHead(HeadTarget headTarget)
{
headTarget.head.SetBoneRotation(headTarget.head.target.transform.rotation);
if (headTarget.humanoid.targetsRig.runtimeAnimatorController == null &&
headTarget.head.target.confidence.position > 0)
{
headTarget.head.SetBonePosition(headTarget.head.target.transform.position);
}
}
public TargetedHeadBone(HeadTarget headTarget)
{
this.headTarget = headTarget;
boneId = Bone.Head;
bone.minAngles = minHeadAngles;
bone.maxAngles = maxHeadAngles;
bone.length = 0.1F;
}
public EyeTarget(FaceTarget face, bool isLeft)
{
this.face = face;
this.headTarget = face.headTarget;
this.isLeft = isLeft;
boneId = isLeft ? Bone.LeftEye : Bone.RightEye;
upperLid.boneId = isLeft ? Bone.LeftUpperLid : Bone.RightUpperLid;
lowerLid.boneId = isLeft ? Bone.LeftLowerLid : Bone.RightLowerLid;
}
public override void Init(HeadTarget _headTarget)
{
base.Init(_headTarget);
if (headTarget.humanoid != null)
#if hSTEAMVR
{ tracker = headTarget.humanoid.steam; }
#elif hOPENVR
{ tracker = headTarget.humanoid.openVR; }
#endif
}
private static void UpdateNeckTargetFromHead(HeadTarget headTarget)
{
Vector3 headPosition = headTarget.head.target.transform.position;
Quaternion headRotation = headTarget.head.target.transform.rotation;
headTarget.neck.target.transform.rotation = headTarget.head.target.transform.rotation;
headTarget.neck.target.transform.position = headPosition - headTarget.neck.target.transform.rotation * Vector3.up * headTarget.neck.bone.length;
headTarget.head.target.transform.position = headPosition;
headTarget.head.target.transform.rotation = headRotation;
}
public TargetProps(SerializedObject serializedObject, UnityHeadSensor _sensor, HeadTarget _headTarget, string unitySensorName)
{
enabledProp = serializedObject.FindProperty(unitySensorName + ".enabled");
sensorTransformProp = serializedObject.FindProperty(unitySensorName + ".sensorTransform");
sensor2TargetPositionProp = serializedObject.FindProperty(unitySensorName + ".sensor2TargetPosition");
sensor2TargetRotationProp = serializedObject.FindProperty(unitySensorName + ".sensor2TargetRotation");
headTarget = _headTarget;
sensor = _sensor;
sensor.Init(headTarget);
}
private void FirstPersonCameraInspector(HeadTarget headTarget)
{
if (headTarget.unityVRHead == null)
{
return;
}
#if hSTEAMVR && hVIVETRACKER && (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX)
EditorGUI.BeginDisabledGroup(headTarget.humanoid.steam.enabled && headTarget.viveTracker.enabled);
#endif
bool wasEnabled = headTarget.unityVRHead.enabled;
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
#if hSTEAMVR && hVIVETRACKER && (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX)
if (headTarget.humanoid.steam.enabled && headTarget.viveTracker.enabled)
{
headTarget.unityVRHead.enabled = false;
}
#endif
bool enabled = EditorGUILayout.ToggleLeft(headTarget.unityVRHead.name, headTarget.unityVRHead.enabled, GUILayout.MinWidth(80));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(headTarget, enabled ? "Enabled " : "Disabled " + headTarget.unityVRHead.name);
headTarget.unityVRHead.enabled = enabled;
}
EditorGUILayout.EndHorizontal();
#if hFACE
if (enabled) // && microphoneEnabledProp != null) {
{
EditorGUI.indentLevel++;
microphoneEnabledProp.boolValue = EditorGUILayout.ToggleLeft("Microphone", microphoneEnabledProp.boolValue);
EditorGUI.indentLevel--;
}
#endif
if (!Application.isPlaying)
{
UnityVRHead.CheckCamera(headTarget);
if (!wasEnabled && headTarget.unityVRHead.enabled)
{
UnityVRHead.AddCamera(headTarget);
}
else if (wasEnabled && !headTarget.unityVRHead.enabled)
{
UnityVRHead.RemoveCamera(headTarget);
}
}
#if hSTEAMVR && hVIVETRACKER && (UNITY_STANDALONE_WIN || UNITY_STANDALONE_OSX)
EditorGUI.EndDisabledGroup();
#endif
}
protected static void CheckHmdComponent(HeadTarget headTarget)
{
if (headTarget.oculus.sensorTransform == null)
{
return;
}
OculusHmdComponent sensorComponent = headTarget.oculus.sensorTransform.GetComponent <OculusHmdComponent>();
if (sensorComponent == null)
{
headTarget.oculus.sensorTransform.gameObject.AddComponent <OculusHmdComponent>();
}
}
public static Camera GetCamera(HeadTarget headTarget) {
if (headTarget.unityVRHead.camera != null)
return headTarget.unityVRHead.camera;
Camera camera = headTarget.GetComponentInChildren<Camera>();
if (headTarget.unityVRHead.enabled) {
camera = CheckCamera(headTarget);
if (camera == null)
camera = headTarget.GetComponentInChildren<Camera>();
}
return camera;
}
/// <summary>
/// What at we looking at: a humanoid?
/// </summary>
/// <param name="hit">Hit information the raycast from the eyes</param>
/// <returns>The object we are looking at</returns>
private GameObject DetermineFocusObject(RaycastHit hit)
{
if (hit.rigidbody != null)
{
// Humanoid has a rigidbody and a body collider
HeadTarget headTarget = hit.rigidbody.GetComponent <HeadTarget>();
if (headTarget != null)
{
// We are looking at the head of a humanoid
return(headTarget.humanoid.gameObject);
}
}
return(hit.transform.gameObject);
}
protected static void CheckRigidbodyComponent(HeadTarget headTarget)
{
if (headTarget.optitrack.sensorTransform == null)
{
return;
}
OptitrackRigidbodyComponent sensorComponent = headTarget.optitrack.sensorTransform.GetComponent <OptitrackRigidbodyComponent>();
if (sensorComponent == null)
{
headTarget.optitrack.sensorTransform.gameObject.AddComponent <OptitrackRigidbodyComponent>();
}
}
private static void CheckSensorComponent(HeadTarget headTarget)
{
if (headTarget.viveTracker.sensorTransform == null)
{
return;
}
ViveTrackerComponent sensorComponent = headTarget.viveTracker.sensorTransform.GetComponent <ViveTrackerComponent>();
if (sensorComponent == null)
{
sensorComponent = headTarget.viveTracker.sensorTransform.gameObject.AddComponent <ViveTrackerComponent>();
}
}
public override void Start(HumanoidControl _humanoid, HumanoidTarget _target)
{
base.Start(_humanoid, _target);
headTarget = (HeadTarget)_target;
if (headTarget.neck.bone.transform != null)
{
headTarget.neck.bone.transform.rotation = headTarget.neck.target.transform.rotation * headTarget.neck.target.toBoneRotation;
}
if (headTarget.head.bone.transform != null)
{
headTarget.head.bone.transform.rotation = headTarget.head.target.transform.rotation * headTarget.head.target.toBoneRotation;
}
}
protected static void CheckHmdComponent(HeadTarget headTarget)
{
if (headTarget.steamVR.sensorTransform == null)
{
return;
}
SteamVrHmdComponent sensorComponent = headTarget.steamVR.sensorTransform.GetComponent <SteamVrHmdComponent>();
if (sensorComponent == null)
{
headTarget.steamVR.sensorTransform.gameObject.AddComponent <SteamVrHmdComponent>();
}
}
private static void FirstPersonCameraInspector(HeadTarget headTarget)
{
if (headTarget.unityVRHead == null || headTarget.humanoid == null)
{
return;
}
#if hSTEAMVR && hVIVETRACKER && UNITY_STANDALONE_WIN
EditorGUI.BeginDisabledGroup(headTarget.humanoid.steam.enabled && headTarget.viveTracker.enabled);
#endif
bool wasEnabled = headTarget.unityVRHead.enabled;
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
#if hSTEAMVR && hVIVETRACKER && UNITY_STANDALONE_WIN
if (headTarget.humanoid.steam.enabled && headTarget.viveTracker.enabled)
{
headTarget.unityVRHead.enabled = false;
}
#endif
GUIContent text = new GUIContent(
"First Person Camera",
"Enables a first person camera. Disabling and enabling again reset the camera position"
);
bool enabled = EditorGUILayout.ToggleLeft(text, headTarget.unityVRHead.enabled, GUILayout.Width(200));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(headTarget, enabled ? "Enabled " : "Disabled " + headTarget.unityVRHead.name);
headTarget.unityVRHead.enabled = enabled;
}
EditorGUILayout.EndHorizontal();
if (!Application.isPlaying && !HumanoidControl_Editor.IsPrefab(headTarget.humanoid))
{
UnityVRHead.CheckCamera(headTarget);
if (!wasEnabled && headTarget.unityVRHead.enabled)
{
UnityVRHead.AddCamera(headTarget);
}
else if (wasEnabled && !headTarget.unityVRHead.enabled)
{
UnityVRHead.RemoveCamera(headTarget);
}
}
#if hSTEAMVR && hVIVETRACKER && UNITY_STANDALONE_WIN
EditorGUI.EndDisabledGroup();
#endif
}
