public static void SendAvatarPose(this IHumanoidNetworking networking, HumanoidControl humanoid)
{
networking.Send(humanoid.nwId);
networking.Send(humanoid.humanoidId);
networking.Send(Time.time); // Pose Time
byte targetMask = DetermineActiveTargets(humanoid);
networking.Send(targetMask);
if (debug <= Debug.Debug)
{
UnityEngine.Debug.Log(humanoid.nwId + ": Send Pose Humanoid " + humanoid.humanoidId + ", targetMask = " + targetMask);
}
// Humanoid Transform is always sent
networking.SendTarget(humanoid.transform);
SendAvatarTargets(networking, humanoid, targetMask);
if (IsTargetActive(targetMask, HumanoidControl.TargetId.LeftHand))
{
networking.SendAvatarHandPose(humanoid.leftHandTarget);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.RightHand))
{
networking.SendAvatarHandPose(humanoid.rightHandTarget);
}
}
public override void Start(HumanoidControl _humanoid, Transform targetTransform)
{
base.Start(_humanoid, targetTransform);
optitrackTracker = handTarget.humanoid.optitrack;
tracker = optitrackTracker;
if (handTarget.isLeft)
{
shoulderBoneID = Bone.LeftShoulder;
upperArmBoneID = Bone.LeftUpperArm;
forearmBoneID = Bone.LeftForearm;
handBoneID = Bone.LeftHand;
}
else
{
shoulderBoneID = Bone.RightShoulder;
upperArmBoneID = Bone.RightUpperArm;
forearmBoneID = Bone.RightForearm;
handBoneID = Bone.RightHand;
}
if (sensorTransform != null)
{
optitrackRigidbody = sensorTransform.GetComponent <OptitrackRigidbodyComponent>();
if (optitrackRigidbody != null)
{
optitrackRigidbody.StartComponent(tracker.trackerTransform);
}
}
}
public void OnLetGo()
{
if (grabbingHandTarget == null)
{
return;
}
HumanoidControl humanoid = grabbingHandTarget.humanoid;
if (humanoid == null)
{
return;
}
if (interactionPointer != null)
{
interactionPointer.active = false;
}
ControllerInput controllerInput = humanoid.GetComponent <ControllerInput>();
if (controllerInput == null)
{
return;
}
if (grabbingHandTarget.isLeft)
{
controllerInput.leftTrigger1Input.SetMethod((InputEvent.FloatMethod)null, InputEvent.EventType.None);
}
else
{
controllerInput.rightTrigger1Input.SetMethod((InputEvent.FloatMethod)null, InputEvent.EventType.None);
}
}
protected SubTracker NewLighthouse(HumanoidControl humanoid, uint sensorId)
{
SubTracker subTracker = OpenVRTracker.Create(this);
subTracker.subTrackerId = (int)sensorId;
return(subTracker);
}
void SendEvent(HumanoidControl humanCtrl, int eventValue)
{
if (humanCtrl != null)
{
humanCtrl.HandleEvent(eventValue);
}
}
public int animatorParameterIndex; // index of the animator parameter, only necessary for editor
private void SetAnimatorParameter()
{
if (animatorParameterName == null)
{
return;
}
HumanoidControl humanoid = targetGameObject.GetComponent <HumanoidControl>();
switch (animatorParameterType)
{
case AnimatorControllerParameterType.Bool:
humanoid.targetsRig.SetBool(animatorParameterName, _boolValue);
break;
case AnimatorControllerParameterType.Float:
humanoid.targetsRig.SetFloat(animatorParameterName, _floatValue);
break;
case AnimatorControllerParameterType.Int:
humanoid.targetsRig.SetFloat(animatorParameterName, _intValue);
break;
case AnimatorControllerParameterType.Trigger:
if (_boolValue && boolChanged)
{
humanoid.targetsRig.SetTrigger(animatorParameterName);
}
break;
default:
break;
}
}
public void OnEnable()
{
handTarget = (HandTarget)target;
if (handTarget.humanoid == null)
{
handTarget.humanoid = GetHumanoid(handTarget);
}
humanoid = handTarget.humanoid;
if (humanoid == null)
{
return;
}
humanoid.InitTargets();
InitEditors();
handTarget.InitSensors();
InitConfiguration(handTarget);
InitSettings();
InitOther();
InitHandPose(handTarget);
if (!Application.isPlaying)
{
SetSensor2Target();
}
}
//public Transform stretchlessTarget;
#region Init
//public void Init(Transform targetTransform) {
// handTarget = targetTransform.GetComponent<HandTarget>();
//}
public override void Start(HumanoidControl humanoid, HumanoidTarget _target)
{
handTarget = (HandTarget)_target;
if (handTarget.humanoid.avatarRig == null || handTarget.hand.bone.transform == null)
{
return;
}
if (humanoid.physics && handTarget.physics)
{
AdvancedHandPhysics physics = handTarget.hand.bone.transform.GetComponent <AdvancedHandPhysics>();
if (physics == null)
{
physics = handTarget.hand.bone.transform.gameObject.AddComponent <AdvancedHandPhysics>();
}
physics.handTarget = handTarget;
physics.mode = AdvancedHandPhysics.DeterminePhysicsMode(handTarget.handRigidbody, HandInteraction.kinematicMass);
}
else
{
BasicHandPhysics physics = handTarget.hand.bone.transform.GetComponent <BasicHandPhysics>();
if (physics == null)
{
physics = handTarget.hand.bone.transform.gameObject.AddComponent <BasicHandPhysics>();
}
physics.handTarget = handTarget;
}
}
public override void Start(HumanoidControl _humanoid, Transform targetTransform)
{
base.Start(_humanoid, targetTransform);
tracker = headTarget.humanoid.realsenseTracker;
sensor = new RealsenseHead(_humanoid.realsenseTracker.realsenseDevice, headTracking);
}
public virtual bool AddTracker(HumanoidControl humanoid, string resourceName)
{
GameObject realWorld = HumanoidControl.GetRealWorld(humanoid.transform);
trackerTransform = FindTrackerObject(realWorld, name);
if (trackerTransform == null)
{
GameObject model = Resources.Load(resourceName) as GameObject;
if (model != null)
{
GameObject trackerObject = GameObject.Instantiate(model);
trackerObject.name = name;
trackerTransform = trackerObject.transform;
}
else
{
GameObject trackerObject = new GameObject(name);
trackerTransform = trackerObject.transform;
}
trackerTransform.parent = realWorld.transform;
trackerTransform.position = humanoid.transform.position;
trackerTransform.rotation = humanoid.transform.rotation;
return(true);
}
return(false);
}
public void ShowPose(HumanoidControl humanoid, Side showSide)
{
int bestPose = -1;
float bestScore = -1;
ResetAffectedBones(humanoid, showSide);
int i = 0;
foreach (MixedPose mixedPose in mixedPoses)
{
if (mixedPose != null && mixedPose.pose != null)
{
mixedPose.pose.ShowAdditive(humanoid, showSide, mixedPose.value);
}
mixedPose.UpdateScore(humanoid, showSide);
if (mixedPose.score > bestScore)
{
bestPose = i;
bestScore = mixedPose.score;
detectedPose = mixedPose.pose;
}
i++;
}
if (bestPose != -1)
{
currentPoseIx = bestPose;
}
}
public override void StartTracker(HumanoidControl _humanoid)
{
humanoid = _humanoid;
if (humanoid.headTarget.unityVRHead.enabled && UnityVRDevice.xrDevice == UnityVRDevice.XRDeviceType.OpenVR)
{
enabled = true;
}
if (!enabled || UnityVRDevice.xrDevice != UnityVRDevice.XRDeviceType.OpenVR)
{
return;
}
TraditionalDevice.gameControllerEnabled = false;
// Game controllers interfere with SteamVR Controller Input ... :-(
SteamDevice.Start();
AddTracker(humanoid, "SteamVR");
SteamDevice.onNewSensor += OnNewSensor; // trackerId => ViveTracker.NewViveTracker(humanoid, trackerId);
#if hVIVETRACKER
Debug.Log("Detecting Vive Tracker positions.\nMake sure the Vive HMD is looking in the same direction as the user!");
#endif
}
public static byte DetermineActiveTargets(HumanoidControl humanoid, out int activeTargetCount)
{
byte targetMask = 0;
HumanoidTarget[] targets =
{
humanoid.hipsTarget,
humanoid.headTarget,
humanoid.leftHandTarget,
humanoid.rightHandTarget,
humanoid.leftFootTarget,
humanoid.rightFootTarget
};
activeTargetCount = 0;
for (int i = 0; i < targets.Length; i++)
{
if (targets[i].main != null && (targets[i].main.target.confidence.position > 0.2F || targets[i].main.target.confidence.rotation > 0.2F) || i == 1)
{
// for now, we always send the head to match the avatar's position well
targetMask |= (byte)(1 << (i + 1));
activeTargetCount++;
}
}
return(targetMask);
}
private static void SendAvatarTargets(IHumanoidNetworking networking, HumanoidControl humanoid, byte targetMask)
{
if (IsTargetActive(targetMask, HumanoidControl.TargetId.Hips))
{
networking.SendTarget(humanoid.hipsTarget.transform);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.Head))
{
networking.SendTarget(humanoid.headTarget.transform);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.LeftHand))
{
networking.SendTarget(humanoid.leftHandTarget.transform);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.RightHand))
{
networking.SendTarget(humanoid.rightHandTarget.transform);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.LeftFoot))
{
networking.SendTarget(humanoid.leftFootTarget.transform);
}
if (IsTargetActive(targetMask, HumanoidControl.TargetId.RightFoot))
{
networking.SendTarget(humanoid.rightFootTarget.transform);
}
}
protected Vector3 CalulateIdleHandPosition(Quaternion avatarRotation)
{
HumanoidControl humanoid = handTarget.humanoid;
float hipsWidth = 0.4F;
if (humanoid.leftFootTarget.upperLeg.bone.transform != null && humanoid.rightFootTarget.upperLeg.bone.transform != null)
{
hipsWidth = Vector3.Distance(humanoid.leftFootTarget.upperLeg.bone.transform.position, humanoid.rightFootTarget.upperLeg.bone.transform.position);
}
float handDistanceFromHips = hipsWidth / 2 + 0.15F;
Vector3 positionBetweenArms = humanoid.headTarget.neck.target.transform.position;
if (handTarget.upperArm.bone.transform != null && handTarget.otherHand.upperArm.bone.transform != null)
{
positionBetweenArms = (handTarget.upperArm.bone.transform.position + handTarget.otherHand.upperArm.bone.transform.position) / 2;
}
Vector3 handPosition =
new Vector3(
positionBetweenArms.x,
handTarget.upperArm.bone.transform != null ? handTarget.upperArm.bone.transform.position.y : humanoid.headTarget.neck.target.transform.position.y,
positionBetweenArms.z
);
handPosition += avatarRotation *
new Vector3(
(handTarget.isLeft ? -handDistanceFromHips : handDistanceFromHips),
-(handTarget.upperArm.bone.length + handTarget.forearm.bone.length - 0.05F),
0
);
return(handPosition);
}
public override void StartTracker(HumanoidControl _humanoid)
{
humanoid = _humanoid;
if (!enabled)
{
return;
}
if (useLeapPackage && isHeadMounted)
{
AddXRServiceProvider();
if (leapProvider == null)
{
leapProvider = Leap.Unity.Hands.Provider;
}
leapProvider.OnUpdateFrame -= OnUpdateFrame;
leapProvider.OnUpdateFrame += OnUpdateFrame;
}
else
{
device = new LeapDevice();
device.Init();
leapTransform = device.GetTracker();
AddTracker(humanoid, "LeapMotion");
if (isHeadMounted)
{
SetTrackerOnCamera();
}
}
}
public new static GameObject GetTargetGameObject(InputEvent.InputType inputType, GameObject gameObject)
{
HumanoidControl humanoid = gameObject.GetComponent <HumanoidControl>();
if (humanoid == null)
{
return(gameObject);
}
switch ((ControllerInput.InputType)inputType)
{
case ControllerInput.InputType.None:
return(null);
case ControllerInput.InputType.Head:
return(humanoid.headTarget.gameObject);
case ControllerInput.InputType.LeftHand:
return(humanoid.leftHandTarget.gameObject);
case ControllerInput.InputType.RightHand:
return(humanoid.rightHandTarget.gameObject);
case ControllerInput.InputType.Humanoid:
return(humanoid.gameObject);
default:
return(gameObject);
}
}
// 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 new Tracker tracker;
#region Start
public override void Start(HumanoidControl humanoid, Transform targetTransform)
{
base.Start(humanoid, targetTransform);
camera = headTarget.GetComponentInChildren <Camera>();
if (enabled)
{
CreateUnityVRRoot();
camera = CheckCamera(headTarget);
if (camera == null && cameraTransform != null)
{
cameraTransform.gameObject.SetActive(true);
camera = headTarget.GetComponentInChildren <Camera>();
}
else if (camera != null)
{
cameraTransform = camera.transform;
}
CheckCameraLocation();
}
else if (camera != null)
{
camera.gameObject.SetActive(false);
}
}
// 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 OnActorAppears(int actorID)
{
Debug.Log("Actor " + actorID + " appears");
if (nHumanoids > 2)
{
return; // we do not support more than 2 actors
}
HumanoidControl humanoid = SpawnHumanoid();
if (humanoid == null)
{
return;
}
humanoid.neuronTracker.Enable();
//humanoid.neuronTracker.actorID = actorID;
humanoid.animatorEnabled = false;
humanoid.useGravity = false;
humanoid.physics = false;
spawnedHumanoids[actorID] = humanoid;
nHumanoids++;
}
/// <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;
}
public virtual bool UseSkill(int skillBaseID, HumanoidControl targetObj = null)
{
try
{
/*SkillBase_Tbl SkillTab = com.jdxk.Configs.TemplatePool.Instance.GetDataByKey<SkillBase_Tbl>(skillBaseID);
* if (null == SkillTab)
* {
* return false;
* }
*
* this.TargetObj = targetObj;
* SkillID = skillBaseID;
* Skill = SkillTab.aniID;
* if (null != targetObj)
* {
* Utility.LookAtTargetImmediately(humanoidControl, targetObj);
* }
*
* //释放技能飘字
* if (!string.IsNullOrEmpty(SkillTab.fontname))
* {
* HUDTextManager.Instance.SetText(HUDTextManager.TextType.SKILL, SkillTab.fontname, humanoidControl);
* }*/
return(true);
}
catch (UnityException uex)
{
LogManager.Log(uex.ToString(), LogType.Fatal);
}
return(false);
}
public static void AddTracker(HumanoidControl humanoid)
{
// you cannot find a tracker in a disabled gameObject
if (!humanoid.gameObject.activeInHierarchy)
{
return;
}
GameObject realWorld = HumanoidControl.GetRealWorld(humanoid.transform);
Transform trackerTransform = realWorld.transform.Find(UnityVRDevice.trackerName);
if (trackerTransform == null)
{
UnityVRDevice.trackerObject = new GameObject {
name = UnityVRDevice.trackerName
};
UnityVRDevice.trackerObject.transform.parent = realWorld.transform;
UnityVRDevice.trackerObject.transform.localPosition = Vector3.zero;
}
else
{
UnityVRDevice.trackerObject = trackerTransform.gameObject;
}
}
private void UpdatePose(HumanoidControl humanoid, Bone boneId)
{
BonePose poseTargetBone = CheckBone(boneId);
poseTargetBone.UpdateTranslation(humanoid);
poseTargetBone.UpdateRotation(humanoid);
}
//Transform chestTargetTransform;
public override void Start(HumanoidControl _humanoid, Transform targetTransform)
{
base.Start(_humanoid, targetTransform);
neuronTracker = handTarget.humanoid.neuronTracker;
tracker = neuronTracker;
//if (handTarget.humanoid.hipsTarget.chest.target.transform != null) {
// chestTargetTransform = handTarget.humanoid.hipsTarget.chest.target.transform;
//}
//else {
// chestTargetTransform = handTarget.humanoid.hipsTarget.hips.target.transform;
//}
if (neuronTracker.device == null)
{
return;
}
Side side = handTarget.isLeft ? Side.Left : Side.Right;
shoulderSensor = neuronTracker.device.GetBone(0, side, SideBone.Shoulder);
upperArmSensor = neuronTracker.device.GetBone(0, side, SideBone.UpperArm);
forearmSensor = neuronTracker.device.GetBone(0, side, SideBone.Forearm);
handSensor = neuronTracker.device.GetBone(0, side, SideBone.Hand);
for (int i = 0; i < (int)Finger.Count; i++)
{
StartFinger(side, handTarget.fingers.allFingers[i], i);
}
}
public void TeleportHumanoid()
{
if (!active)
{
return;
}
HumanoidControl humanoid = transformToTeleport.GetComponent <HumanoidControl>();
if (humanoid == null)
{
transformToTeleport.Teleport(focusPointObj.transform.position);
}
else
{
Vector3 interactionPointerPosition = humanoid.GetHumanoidPosition() - transformToTeleport.position;
switch (transportType)
{
case TransportType.Teleport:
transformToTeleport.Teleport(focusPointObj.transform.position - interactionPointerPosition);
break;
case TransportType.Dash:
StartCoroutine(TransformMovements.DashCoroutine(transformToTeleport, focusPointObj.transform.position - interactionPointerPosition));
break;
default:
break;
}
}
}
/// <summary>Animates the arm swing based on foot movements</summary>
/// <returns>boolean indicating is the arms are swinging</returns>
protected bool ArmSwingAnimation()
{
HumanoidControl humanoid = handTarget.humanoid;
HipsTarget hipsTarget = humanoid.hipsTarget;
Vector3 newPosition;
float localFootZ;
if (handTarget.isLeft)
{
localFootZ = hipsTarget.transform.InverseTransformPoint(humanoid.rightFootTarget.transform.position).z;
Vector3 localFootPosition = Quaternion.Inverse(hipsTarget.hips.bone.targetRotation) * (humanoid.rightFootTarget.transform.position - humanoid.transform.position);
newPosition = localFootPosition + foot2hand;
handTarget.hand.target.transform.rotation = handTarget.forearm.bone.targetRotation;
handTarget.hand.target.confidence.rotation = 0.2F;
}
else
{
localFootZ = hipsTarget.transform.InverseTransformPoint(humanoid.leftFootTarget.transform.position).z;
Vector3 localFootPosition = Quaternion.Inverse(hipsTarget.hips.bone.targetRotation) * (humanoid.leftFootTarget.transform.position - humanoid.transform.position);
newPosition = localFootPosition + foot2hand;
handTarget.hand.target.transform.rotation = handTarget.forearm.bone.targetRotation;
handTarget.hand.target.confidence.rotation = 0.2F;
}
float newY = Mathf.Abs(localFootZ / 4 + 0.02f) - humanoid.transform.position.y;
handTarget.hand.target.transform.position = hipsTarget.transform.TransformPoint(new Vector3(newPosition.x, newY, newPosition.z));
handTarget.hand.target.confidence.position = 0.2F;
return(true);
}
public void OnGrabbed(HandTarget handTarget)
{
grabbingHandTarget = handTarget;
HumanoidControl humanoid = handTarget.humanoid;
if (humanoid == null)
{
return;
}
if (interactionPointer != null)
{
interactionPointer.active = true;
}
ControllerInput controllerInput = humanoid.GetComponent <ControllerInput>();
if (controllerInput == null)
{
return;
}
if (handTarget.isLeft)
{
controllerInput.leftTrigger1Input.SetMethod(Fire, InputEvent.EventType.Start);
}
else
{
controllerInput.rightTrigger1Input.SetMethod(Fire, InputEvent.EventType.Start);
}
}
private Vector3 UprightCheck(HumanoidControl humanoid, Vector3 hipsPosition, Vector3 neckPosition, Vector3 spineDirection, Vector3 backVector)
{
float headPositionY = neckPosition.y - humanoid.transform.position.y;
float hipsAngle = Vector3.Angle(humanoid.up, spineDirection);
float verticalBodyStretch = headPositionY - humanoid.avatarNeckHeight;
if (verticalBodyStretch >= -0.01F && (hipsAngle < 20 || Mathf.Abs(spineDirection.normalized.x) < 0.2F || Mathf.Abs(spineDirection.z) < 0.15F))
{
// standing upright
//Debug.Log("Upright " + verticalBodyStretch + " " + hipsAngle + " " + spineDirection.normalized);
Vector3 uprightSpine = humanoid.transform.rotation * torsoUprightOrientation * backVector;
Vector3 targetHipPosition = neckPosition + uprightSpine;
Vector3 toTargetHipPosition = targetHipPosition - hipsPosition;
if (hipsAngle < 30)
{
hipsPosition = hipsPosition + Vector3.ClampMagnitude(toTargetHipPosition, 0.02F);
}
else
{
hipsPosition = targetHipPosition;
}
}
//else
// Debug.Log("Bent");
return(hipsPosition);
}
