void IHumanoidNetworking.Grab(HandTarget handTarget, GameObject obj, bool rangeCheck)
{
if (handTarget.humanoid.isRemote)
{
return;
}
if (debug <= HumanoidNetworking.Debug.Info)
{
Debug.Log(handTarget.humanoid.nwId + ": Grab " + obj);
}
PhotonView objView = obj.GetComponent <PhotonView>();
if (objView == null)
{
if (debug <= HumanoidNetworking.Debug.Error)
{
Debug.LogError("Photon Grab: Grabbed object does not have a PhotonView " + obj);
}
}
else
#if hPHOTON2
{ photonView.RPC("RpcGrab", RpcTarget.Others, handTarget.humanoid.humanoidId, objView.ViewID, handTarget.isLeft, rangeCheck); }
#else
{ photonView.RPC("RpcGrab", PhotonTargets.Others, handTarget.humanoid.humanoidId, objView.viewID, handTarget.isLeft, rangeCheck); }
#endif
}
private void FingerConfigurationInspector(HandTarget handTarget, FingersTarget.TargetedFinger digit, int fingerIndex, string label)
{
Transform proximalBone = (Transform)EditorGUILayout.ObjectField(label, digit.proximal.bone.transform, typeof(Transform), true);
if (proximalBone == null || proximalBone != digit.proximal.bone.transform)
{
if (proximalBone == null)
{
proximalBone = FingersTarget.GetFingerBone(handTarget, (Finger)fingerIndex, Humanoid.Tracking.FingerBones.Proximal);
}
if (proximalBone != null && proximalBone.childCount == 1)
{
digit.intermediate.bone.transform = proximalBone.GetChild(0);
if (digit.intermediate.bone.transform != null && digit.intermediate.bone.transform.childCount == 1)
{
digit.distal.bone.transform = digit.intermediate.bone.transform.GetChild(0);
}
else
{
digit.distal.bone.transform = null;
}
}
else
{
digit.intermediate.bone.transform = null;
}
}
digit.proximal.bone.transform = proximalBone;
}
private void HandPoseInspector(HandTarget handTarget)
{
EditorGUILayout.BeginHorizontal();
showHandPoses = EditorGUILayout.Foldout(showHandPoses, "Hand Pose", true);
EditorGUI.indentLevel++;
GetPoseNames();
int poseIx = EditorGUILayout.Popup(handTarget.poseMixer.currentPoseIx, poseNames);
if (poseIx != handTarget.poseMixer.currentPoseIx)
{
handTarget.poseMixer.currentPoseIx = poseIx;
handTarget.poseMixer.SetPoseValue(poseIx);
SceneView.RepaintAll();
}
EditorGUI.indentLevel--;
EditorGUILayout.EndHorizontal();
if (showHandPoses)
{
EditorGUI.indentLevel++;
Pose_Editor.PoseMixerInspector(handTarget.poseMixer, humanoid);
EditorGUI.indentLevel--;
}
if (!Application.isPlaying)
{
handTarget.poseMixer.ShowPose(humanoid, handTarget.isLeft ? Side.Left : Side.Right);
}
}
public static HandTarget Inspector(HandTarget handTarget, string name)
{
if (handTarget == null)
{
return(handTarget);
}
EditorGUILayout.BeginHorizontal();
Transform defaultTargetTransform = handTarget.GetDefaultTarget(handTarget.humanoid);
Transform targetTransform = handTarget.transform ?? defaultTargetTransform;
GUIContent text = new GUIContent(
name,
"The transform controlling the " + name
);
targetTransform = (Transform)EditorGUILayout.ObjectField(text, targetTransform, typeof(Transform), true);
if (!Application.isPlaying)
{
if (targetTransform == defaultTargetTransform && GUILayout.Button("Show", GUILayout.MaxWidth(60)))
{
// Call static method CreateTarget on target
handTarget = (HandTarget)handTarget.GetType().GetMethod("CreateTarget").Invoke(null, new object[] { handTarget });
}
else if (targetTransform != handTarget.transform)
{
handTarget = (HandTarget)handTarget.GetType().GetMethod("SetTarget").Invoke(null, new object[] { handTarget.humanoid, targetTransform, handTarget.isLeft });
}
}
EditorGUILayout.EndHorizontal();
return(handTarget);
}
private void InitConfiguration(HandTarget handTarget)
{
InitShoulderConfiguration(handTarget.shoulder);
InitUpperArmConfiguration(handTarget.upperArm);
InitForearmConfiguration(handTarget.forearm);
InitHandConfiguration(handTarget.hand);
}
public static void Grab(HandTarget handTarget, GameObject obj, bool rangeCheck = true)
{
//if (handTarget.humanoid.humanoidNetworking != null)
// handTarget.humanoid.humanoidNetworking.Grab(handTarget, obj, rangeCheck);
LocalGrab(handTarget, obj, rangeCheck);
}
//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 static void Update(HandTarget handTarget)
{
if (handTarget == null || handTarget.hand.bone.transform == null)
{
return;
}
if (!Application.isPlaying)
{
handTarget.armMovements.FullInverseKinematics(handTarget, handTarget.rotationSpeedLimitation);
}
else if (handTarget.humanoid.targetsRig.runtimeAnimatorController != null && handTarget.hand.target.confidence.position == 0)
{
handTarget.armMovements.FullForwardKinematics(handTarget);
}
else
{
if (handTarget.hand.target.confidence.position >= handTarget.forearm.target.confidence.rotation &&
handTarget.hand.target.confidence.position >= handTarget.upperArm.target.confidence.rotation)
{
handTarget.armMovements.FullInverseKinematics(handTarget, handTarget.rotationSpeedLimitation);
}
else if (handTarget.forearm.target.confidence.position > handTarget.upperArm.target.confidence.rotation)
{
handTarget.armMovements.ForearmForwardKinematics(handTarget);
}
else
{
handTarget.armMovements.FullForwardKinematics(handTarget);
}
}
}
// Forearm Forward Kinematics, rest Inverse Kinematics
private void ForearmForwardKinematics(HandTarget handTarget)
{
Vector3 upperArmUp = CalculateUpperArmUp(handTarget.forearm.target.transform.rotation);
Quaternion upperArmRotation = CalculateUpperArmRotation(handTarget.upperArm.bone.transform.position, upperArmUp, handTarget.forearm.target.transform.position, handTarget.isLeft);
handTarget.upperArm.bone.transform.rotation = upperArmRotation * handTarget.upperArm.target.toBoneRotation;
handTarget.forearm.bone.transform.rotation = handTarget.forearm.target.transform.rotation * handTarget.forearm.target.toBoneRotation;
CalculateStretchlessTarget(handTarget);
if (!handTarget.humanoid.physics || handTarget.handRigidbody.isKinematic)
{
//Quaternion handOrientation = NaturalHandOrientation(forearmRotation);
// Not working good enough yet
if (handTarget.hand.target.confidence.rotation > 0.1F)
{
Quaternion handOrientation = handTarget.hand.target.transform.rotation;
handTarget.hand.bone.transform.rotation = handOrientation * handTarget.hand.target.toBoneRotation;
}
else
{
handTarget.hand.bone.transform.rotation = handTarget.forearm.target.transform.rotation * handTarget.hand.target.toBoneRotation;
}
// We need to set the hand position because it is detached
handTarget.hand.bone.transform.position = handTarget.forearm.bone.transform.position + handTarget.forearm.target.transform.rotation * handTarget.outward * handTarget.forearm.bone.length;
}
}
public Quaternion CalculateUpperArmRotation2(HandTarget handTarget, Vector3 upperArmUp, Vector3 handPosition)
{
float upperArm2HandDistance = Vector3.Distance(handTarget.upperArm.bone.transform.position, handPosition);
float upperArmAngle = ConsineRule(upperArm2HandDistance, handTarget.upperArm.bone.length, handTarget.forearm.bone.length);
if (handTarget.isLeft)
{
upperArmAngle = -upperArmAngle;
}
Vector3 upperArmForward = handPosition - handTarget.upperArm.bone.transform.position;
Quaternion upperArmRotation = Quaternion.LookRotation(upperArmForward, upperArmUp);
upperArmRotation = Quaternion.AngleAxis(upperArmAngle, upperArmRotation * Vector3.up) * upperArmRotation;
if (handTarget.isLeft)
{
upperArmRotation *= Quaternion.Euler(0, 90, 0);
}
else
{
upperArmRotation *= Quaternion.Euler(0, -90, 0);
}
if (handTarget.upperArm.bone.jointLimitations)
{
upperArmRotation = LimitAngle(handTarget.upperArm, ref lastLocalUpperArmRotation, upperArmRotation);
}
return(upperArmRotation);
}
private static Vector3 NaturalHandPosition(HandTarget handTarget)
{
Vector3 handPosition = GetHandPosition(handTarget);
handPosition = HandLimitations(handTarget, handPosition);
return(handPosition);
}
// Forward Kinematics
private void FullForwardKinematics(HandTarget handTarget)
{
if (handTarget.humanoid.physics && (handTarget.handRigidbody == null || !handTarget.handRigidbody.isKinematic))
{
// Hand is colliding, so we need to use Inverse Kinematics
FullInverseKinematics(handTarget);
}
// Still needs rotation speed limits
handTarget.shoulder.SetBoneRotation(handTarget.shoulder.target.transform.rotation);
// Still needs rotation speed limits
handTarget.upperArm.SetBoneRotation(handTarget.upperArm.target.transform.rotation);
//Quaternion forearmRotation = NaturalForearmOrientation(upperArmRotation);
// Not working yet
handTarget.forearm.SetBoneRotation(handTarget.forearm.target.transform.rotation);
CalculateStretchlessTarget(handTarget);
if (!handTarget.humanoid.physics || handTarget.handRigidbody.isKinematic)
{
//Quaternion handOrientation = NaturalHandOrientation(forearmRotation);
// Not working good enough yet
Quaternion handOrientation = handTarget.hand.target.transform.rotation;
handTarget.hand.bone.transform.rotation = handOrientation * handTarget.hand.target.toBoneRotation;
// We need to set the hand position because it is detached
PlaceHandOnForearm(handTarget, handTarget.forearm.target.transform.rotation);
}
}
public void RpcLetGo(int humanoidId, bool isLeft)
{
if (debug <= HumanoidNetworking.Debug.Info)
{
PhotonLog("RpcLetGo");
}
HumanoidControl humanoid = HumanoidNetworking.FindRemoteHumanoid(humanoids, humanoidId);
if (humanoid == null)
{
if (debug <= HumanoidNetworking.Debug.Warning)
{
PhotonLogWarning("Could not find humanoid: " + humanoidId);
}
return;
}
HandTarget handTarget = isLeft ? humanoid.leftHandTarget : humanoid.rightHandTarget;
if (handTarget != null)
{
HandInteraction.LocalLetGo(handTarget);
}
}
public void RpcGrab(int humanoidId, int objViewID, bool isLeft, bool rangeCheck)
{
PhotonView objView = PhotonView.Find(objViewID);
GameObject obj = objView.gameObject;
if (debug <= HumanoidNetworking.Debug.Info)
{
PhotonLog("RpcGrab " + obj);
}
if (obj == null)
{
return;
}
HumanoidControl humanoid = HumanoidNetworking.FindRemoteHumanoid(humanoids, humanoidId);
if (humanoid == null)
{
if (debug <= HumanoidNetworking.Debug.Warning)
{
PhotonLogWarning("Could not find humanoid: " + humanoidId);
}
return;
}
HandTarget handTarget = isLeft ? humanoid.leftHandTarget : humanoid.rightHandTarget;
if (handTarget != null)
{
HandInteraction.LocalGrab(handTarget, obj, rangeCheck);
}
}
private static void GrabRigidbodyParenting(HandTarget handTarget, Rigidbody objRigidbody)
{
GrabMassRedistribution(handTarget.hand.bone.transform.GetComponent <Rigidbody>(), objRigidbody);
handTarget.grabbedRBdata = new StoredRigidbody(objRigidbody);
objRigidbody.transform.parent = handTarget.handPalm;
if (handTarget.humanoid.humanoidNetworking != null)
{
handTarget.humanoid.humanoidNetworking.DisableNetworkSync(objRigidbody.gameObject);
}
//#if hNW_PHOTON
// PhotonTransformView transformView = objRigidbody.GetComponent<PhotonTransformView>();
// if (transformView != null) {
// transformView.m_PositionModel.SynchronizeEnabled = false;
// transformView.m_RotationModel.SynchronizeEnabled = false;
// }
//#endif
if (Application.isPlaying)
{
Object.Destroy(objRigidbody);
}
else
{
Object.DestroyImmediate(objRigidbody, true);
}
}
public static void CheckHandTarget(Handle handle)
{
HandTarget handTarget = (HandTarget)EditorGUILayout.ObjectField("Hand Target", handle.handTarget, typeof(HandTarget), true);
if (handTarget != handle.handTarget)
{
if (handTarget != null)
{
if (handle.handTarget != null)
{
HandInteraction.LetGo(handle.handTarget);
}
if (handTarget.grabbedObject != null)
{
HandInteraction.LetGo(handTarget);
}
HandInteraction.MoveAndGrabHandle(handTarget, handle);
handTarget.transform.parent = handle.transform;
}
else
{
HandInteraction.LetGo(handle.handTarget);
}
}
}
public static void OnTouchEnd(HandTarget handTarget, GameObject obj)
{
if (handTarget.inputModule != null && obj == handTarget.touchedObject)
{
handTarget.inputModule.OnFingerTouchEnd(handTarget.isLeft);
}
}
void IHumanoidNetworking.Grab(HandTarget handTarget, GameObject obj, bool rangeCheck)
{
if (handTarget.humanoid.isRemote)
{
return;
}
if (debug <= HumanoidNetworking.Debug.Info)
{
Debug.Log(handTarget.humanoid.nwId + ": Grab " + obj);
}
NetworkIdentity nwIdentity = obj.GetComponent <NetworkIdentity>();
if (nwIdentity == null)
{
if (debug <= HumanoidNetworking.Debug.Error)
{
Debug.LogError("Grabbed object " + obj + " does not have a network identity " + obj);
}
}
else
{
CmdGrab(handTarget.humanoid.nwId, handTarget.humanoid.humanoidId, obj, handTarget.isLeft, rangeCheck);
}
}
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;
}
public const float maxGrabbingMass = 10; // maxMass you can grab is 10
#region Start
public static void StartInteraction(HandTarget handTarget)
{
// Remote humanoids should not interact
if (handTarget.humanoid.isRemote)
{
return;
}
// Gun Interaction pointer creates an Event System
// First solve that before enabling this warning
// because the warning will appear in standard Grocery Store demo scene
//EventSystem[] eventSystems = Object.FindObjectsOfType<EventSystem>();
//foreach (EventSystem eventSystem in eventSystems) {
// if (eventSystem != null) {
// HumanoidControl eventSystemHumanoid = eventSystem.GetComponent<HumanoidControl>();
// if (eventSystemHumanoid == null)
// Debug.LogWarning("Another EventSystem found: [" + eventSystem.gameObject.name + "]. Humanoid Control interaction may not work properly");
// }
//}
handTarget.inputModule = handTarget.humanoid.GetComponent <Interaction>();
if (handTarget.inputModule == null)
{
handTarget.inputModule = Object.FindObjectOfType <Interaction>();
if (handTarget.inputModule == null)
{
handTarget.inputModule = handTarget.humanoid.gameObject.AddComponent <Interaction>();
}
}
handTarget.inputModule.EnableTouchInput(handTarget.humanoid, handTarget.isLeft, 0);
}
public static void CopyFingerTargetsToRig(HandTarget handTarget)
{
if (handTarget.grabbedObject != null && handTarget.grabbedHandle != null)
{
handTarget.grabbedHandle.SetHandPose(handTarget);
}
}
public static void MoveHandBoneToHandle(HandTarget handTarget, Handle handle)
{
//Vector3 handPosition;
//Quaternion handRotation;
//GetGrabPosition(handTarget, handle, out handPosition, out handRotation);
if (handle.grabType == Handle.GrabType.DefaultGrab ||
handle.grabType == Handle.GrabType.BarGrab)
{
// Should use GetGrabPosition
//handTarget.hand.bone.transform.rotation = handRotation;
Quaternion handleWorldRotation = handle.transform.rotation * Quaternion.Euler(handle.rotation);
Quaternion palm2handRot = Quaternion.Inverse(handTarget.handPalm.localRotation);
handTarget.hand.bone.transform.rotation = handleWorldRotation * palm2handRot;
}
if (handle.grabType == Handle.GrabType.DefaultGrab ||
handle.grabType == Handle.GrabType.BarGrab ||
handle.grabType == Handle.GrabType.BallGrab)
{
//handTarget.hand.bone.transform.position = handPosition;
Vector3 handleWPos = handle.transform.TransformPoint(handle.position);
Vector3 palm2handPos = handTarget.hand.bone.transform.position - handTarget.handPalm.position;
handTarget.hand.bone.transform.position = handleWPos + palm2handPos;
}
}
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 static void GetGrabPosition(HandTarget handTarget, Handle handle, out Vector3 handPosition, out Quaternion handRotation)
{
Vector3 handleWPos = handle.transform.TransformPoint(handle.position);
Quaternion handleWRot = handle.transform.rotation * Quaternion.Euler(handle.rotation);
GetGrabPosition(handTarget, handleWPos, handleWRot, out handPosition, out handRotation);
}
private void ConfigurationInspector(HandTarget handTarget)
{
//if (!target.jointLimitations)
//return;
//handTarget.RetrieveBones();
showConfiguration = EditorGUILayout.Foldout(showConfiguration, "Configuration", true);
if (showConfiguration)
{
EditorGUI.indentLevel++;
ShoulderConfigurationInspector(ref handTarget.shoulder, handTarget.isLeft);
UpperArmConfigurationInspector(ref handTarget.upperArm, handTarget.isLeft);
ForearmConfigurationInspector(ref handTarget.forearm, handTarget.isLeft);
HandConfigurationInspector(ref handTarget.hand, handTarget.isLeft);
showFingerConfiguration = EditorGUILayout.Foldout(showFingerConfiguration, "Fingers", true);
if (showFingerConfiguration)
{
EditorGUI.indentLevel++;
FingersConfigurationInspector(handTarget);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
}
private static bool AlreadyGrabbedWithOtherHand(HandTarget handTarget, Rigidbody objRigidbody)
{
if (handTarget.otherHand == null || handTarget.otherHand.hand.bone.transform == null)
{
return(false);
}
if (objRigidbody.transform == handTarget.otherHand.hand.bone.transform)
{
return(true);
}
if (objRigidbody.isKinematic)
{
Transform parent = objRigidbody.transform.parent;
if (parent == null)
{
return(false);
}
Rigidbody parentRigidbody = parent.GetComponentInParent <Rigidbody>();
if (parentRigidbody == null)
{
return(false);
}
return(AlreadyGrabbedWithOtherHand(handTarget, parentRigidbody));
}
return(false);
}
private void SettingsInspector(HandTarget handTarget)
{
showSettings = EditorGUILayout.Foldout(showSettings, "Settings", true);
if (showSettings)
{
EditorGUI.indentLevel++;
// Cannot use serializedPropery because showRealObjects is a getter/setter
bool showRealObjects = EditorGUILayout.Toggle("Show Real Objects", handTarget.showRealObjects);
if (showRealObjects != handTarget.showRealObjects)
{
handTarget.showRealObjects = showRealObjects;
}
rotationSpeedLimitationProp.boolValue = EditorGUILayout.Toggle("Rotation Speed Limitation", rotationSpeedLimitationProp.boolValue);
touchInteractionProp.boolValue = EditorGUILayout.Toggle("Touch Interaction", touchInteractionProp.boolValue);
physicsProp.boolValue = EditorGUILayout.Toggle("Physics", physicsProp.boolValue);
if (handTarget.humanoid.physics)
{
handTarget.strength = EditorGUILayout.FloatField("Strength", handTarget.strength);
}
EditorGUI.indentLevel--;
}
}
private static void GrabRigidbodyJoint(HandTarget handTarget, Rigidbody objRigidbody, Vector3 anchorPoint, Vector3 rotationAxis)
{
GrabMassRedistribution(handTarget.hand.bone.transform.GetComponent <Rigidbody>(), objRigidbody);
ConfigurableJoint joint = handTarget.hand.bone.transform.gameObject.AddComponent <ConfigurableJoint>();
Collider c = objRigidbody.transform.GetComponentInChildren <Collider>();
joint.connectedBody = c.attachedRigidbody;
joint.anchor = anchorPoint;
joint.axis = rotationAxis;
joint.xMotion = ConfigurableJointMotion.Locked;
joint.yMotion = ConfigurableJointMotion.Locked;
joint.zMotion = ConfigurableJointMotion.Locked;
joint.angularXMotion = ConfigurableJointMotion.Locked; // Free;
joint.angularYMotion = ConfigurableJointMotion.Locked;
joint.angularZMotion = ConfigurableJointMotion.Locked;
joint.projectionMode = JointProjectionMode.PositionAndRotation;
joint.projectionDistance = 0.01F;
joint.projectionAngle = 1;
handTarget.storedCOM = objRigidbody.centerOfMass;
objRigidbody.centerOfMass = joint.connectedAnchor;
}
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);
}
}
public void InitController(SerializedProperty sensorProp, HandTarget handTarget)
{
if (sensorProp == null)
{
return;
}
Init(handTarget);
SerializedProperty sensorTransformProp = sensorProp.FindPropertyRelative("sensorTransform");
sensorTransformProp.objectReferenceValue = sensorTransform;
SerializedProperty targetProp = sensorProp.FindPropertyRelative("target");
targetProp.objectReferenceValue = target;
if (!tracker.enabled || !enabled)
{
return;
}
CheckSensorTransform();
sensorTransformProp.objectReferenceValue = sensorTransform;
ShowSensor(handTarget.humanoid.showRealObjects && handTarget.showRealObjects);
SerializedProperty sensor2TargetPositionProp = sensorProp.FindPropertyRelative("sensor2TargetPosition");
sensor2TargetPositionProp.vector3Value = sensor2TargetPosition;
SerializedProperty sensor2TargetRotationProp = sensorProp.FindPropertyRelative("sensor2TargetRotation");
sensor2TargetRotationProp.quaternionValue = sensor2TargetRotation;
}