//PROCEDURE ON TRIGGER PRESS
protected override void OnSelectEnter(XRBaseInteractor interactor)
{
selected = true;
if (interactor.GetComponent <XRController>().controllerNode == handController)
{
base.OnSelectEnter(interactor);
StoreInteractor(interactor);
MatchAttachmentPoints(interactor);
if (!audioSelectFlag)
{
audioFXSource.PlayOneShot(onButtonPressDown);
audioSelectFlag = true;
}
if (this.gameObject.tag != "Duplicate")
{
moveLocomotionScript.moveSpeed = moveSpeedWhileSelected;
adjustQuadScript.SetAdjustListen(false);
}
else
{
base.trackRotation = true;
}
quadMaterial.SetColor(outlineColorName, selectColorForHandMode);
}
else if (interactor.GetComponent <XRController>().controllerNode == joystickController)
{
if (!audioSelectFlag)
{
audioFXSource.PlayOneShot(onButtonPressDown);
audioSelectFlag = true;
}
moveLocomotionScript.enabled = false;
snapTurnProviderScript.enabled = false;
rotateQuadScript.SetTranslate(true);
rotateQuadScript.SetRotate(false);
if (this.gameObject.tag != "Duplicate")
{
adjustQuadScript.SetAdjustListen(false);
}
quadMaterial.SetColor(outlineColorName, selectColorForJoystickMode);
}
}
IEnumerator SendHapticFeedback(XRBaseInteractor interactor)
{
// Interval between iterations of coroutine, in seconds.
float runInterval = 0.1f;
ActionBasedController controller = interactor.GetComponent <ActionBasedController>();
Vector3 lastAngularVelocity = new Vector3(transform.InverseTransformDirection(m_Rigidbody.angularVelocity).x, 0f, 0f);
while (grabPoint)
{
Vector3 currentAngularVelocity = new Vector3(transform.InverseTransformDirection(m_Rigidbody.angularVelocity).x, 0f, 0f);
Vector3 angularAcceleration = (currentAngularVelocity - lastAngularVelocity) / runInterval;
// If current velocity and acceleration have perpendicular or opposite directions, the wheel is decelerating.
if (Vector3.Dot(currentAngularVelocity.normalized, angularAcceleration.normalized) < 0f)
{
float impulseAmplitude = Mathf.Abs(angularAcceleration.x);
if (impulseAmplitude > 1.5f)
{
float remappedImpulseAmplitude = Remap(impulseAmplitude, 1.5f, 40f, 0f, 1f);
controller.SendHapticImpulse(remappedImpulseAmplitude, runInterval * 2f);
}
}
lastAngularVelocity = currentAngularVelocity;
yield return(new WaitForSeconds(runInterval));
}
}
private void OnHoverEnter(XRBaseInteractor interactor)
{
//TODO: Solve here how to grap the object with two hands to scale!
if (interactorA == null)
{
interactorA = interactor;
initialPositionA = interactor.GetComponent <Collider>().transform.position;
}
else if (interactorB == null)
{
interactorB = interactor;
initialPositionB = interactor.GetComponent <Collider>().transform.position;
}
originalScale = considerParent ? parentToScale.localScale : transform.localScale;
}
protected override void OnSelectEnter(XRBaseInteractor interactor)
{
base.OnSelectEnter(interactor);
if (interactor is XRDirectInteractor)
{
Climber.climbingHand = interactor.GetComponent <XRController>();
}
}
protected override void OnSelectEntered(XRBaseInteractor interactor)
{
base.OnSelectEntered(interactor);
if (interactor is XRDirectInteractor)
{
controller = interactor.GetComponent <ActionBasedController>();
}
}
private void OnBeginInteraction(XRBaseInteractor interactor)
{
currentInteractorTransform = interactor.transform;
proxyHand.EnableProxyHandVisual(interactor.GetComponent <ActionBasedController>(), interactor);
//interactor.GetComponent<XRBaseController>().hideControllerModel = true;
//proxyHand.Activate();
}
//réécrire la fonction OnSelectEntered de XRBaseInteractable
protected override void OnSelectEntered(XRBaseInteractor interactor)
{
base.OnSelectEntered(interactor);
// si interactor = XRDirectInteractor = une manette
if (interactor is XRDirectInteractor)
{
//envoyer cette manette à climbScript
climbScript.climbingHand = interactor.GetComponent <XRController>();
}
}
//réécrire la fonction OnHoverEntered de XRBaseInteractable
protected override void OnHoverEntered(XRBaseInteractor interactor)
{
base.OnHoverEntered(interactor);
//XRDirectInteractor = une manette
if (interactor is XRDirectInteractor)
{
//la main qui tire du script dragMove devient la manette en question
dragMove.draggingHand = interactor.GetComponent <XRController>();
}
}
//PROCEDURE ON HOVER EXIT
protected override void OnHoverExit(XRBaseInteractor interactor)
{
base.OnHoverExit(interactor);
if (this.gameObject.tag != "Duplicate")
{
adjustQuadScript.SetAdjustListen(false);
}
if (interactor.GetComponent <XRController>().controllerNode == joystickController)
{
duplicateQuadScript.SetDuplicateListen(false);
}
}
//PROCEDURE ON TRIGGER RELEASE
protected override void OnSelectExit(XRBaseInteractor interactor)
{
selected = false;
OnDeactivate(interactor);
if (interactor.GetComponent <XRController>().controllerNode == handController)
{
base.OnSelectExit(interactor);
ResetAttachmentPoints(interactor);
ClearInteractor(interactor);
audioSelectFlag = false;
audioActivateFlag = false;
if (this.gameObject.tag != "Duplicate")
{
moveLocomotionScript.moveSpeed = inactiveMoveSpeed;
}
else
{
base.trackRotation = false;
}
}
else if (interactor.GetComponent <XRController>().controllerNode == joystickController)
{
audioSelectFlag = false;
audioActivateFlag = false;
moveLocomotionScript.enabled = true;
snapTurnProviderScript.enabled = true;
rotateQuadScript.SetTranslate(false);
rotateQuadScript.SetRotate(false);
}
}
private void Update()
{
if (interactorA != null && interactorB != null)
{
XRController controllerA = interactorA.GetComponent <XRController>();
XRController controllerB = interactorB.GetComponent <XRController>();
bool stateA;
controllerA.inputDevice.IsPressed(InputHelpers.Button.Trigger, out stateA);
bool stateB;
controllerB.inputDevice.IsPressed(InputHelpers.Button.Trigger, out stateB);
if (stateA && stateB)
{
ManageScale();
}
else
{
onScaleEnd?.Invoke();
interactorA = null;
interactorB = null;
}
}
}
IEnumerator BrakeAssist(XRBaseInteractor interactor)
{
VRWC_XRNodeVelocitySupplier interactorVelocity = interactor.GetComponent <VRWC_XRNodeVelocitySupplier>();
while (grabPoint)
{
// If the interactor's forward/backward movement approximates zero, it is considered to be braking.
if (interactorVelocity.velocity.z < 0.05f && interactorVelocity.velocity.z > -0.05f)
{
m_Rigidbody.AddTorque(-m_Rigidbody.angularVelocity.normalized * 25f);
SpawnGrabPoint(interactor);
}
yield return(new WaitForFixedUpdate());
}
}
public override void ProcessInteractable(XRInteractionUpdateOrder.UpdatePhase updatePhase)
{
if (selectingInteractor)
{
transform.position = selectingInteractor.attachTransform.position;
transform.rotation = selectingInteractor.attachTransform.rotation;
}
if (secondInteractor && selectingInteractor)
{
onSecond = true;
if (snapToSecondHand)
{
selectingInteractor.attachTransform.rotation = GetTwoHandRotation();
}
else if (!snapToSecondHand)
{
selectingInteractor.attachTransform.rotation = GetTwoHandRotation() * initalRotationOffset;
}
if (secondInteractor && second)
{
second.position = secondPos.position;
second.rotation = secondInteractor.GetComponent <XRController>().controllerNode == UnityEngine.XR.XRNode.LeftHand || secondPos.localRotation.z == 0 ? secondPos.rotation : secondPos.rotation * Quaternion.Euler(0, 0, 180);
}
if (selectingInteractor && first)
{
first.position = firstPos.position;
first.rotation = selectingInteractor.GetComponent <XRController>().controllerNode == UnityEngine.XR.XRNode.LeftHand || firstPos.localRotation.z == 0 ? firstPos.rotation : firstPos.rotation * Quaternion.Euler(0, 0, 180);
}
}
else if (!secondInteractor && selectingInteractor)
{
onSecond = false;
if (selectingInteractor && first)
{
first.position = firstPos.position;
first.rotation = selectingInteractor.GetComponent <XRController>().controllerNode == UnityEngine.XR.XRNode.LeftHand || firstPos.localRotation.z == 0 ? firstPos.rotation : firstPos.rotation * Quaternion.Euler(0, 0, 180);
}
}
base.ProcessInteractable(updatePhase);
}
protected override void OnSelectEnter(XRBaseInteractor interactor)
{
if (interactor is XRDirectInteractor)
{
controllerPos = interactor.gameObject.transform;
initalInteractor = (XRDirectInteractor)interactor;
if (interactor.GetComponent <XRController>().controllerNode == XRNode.LeftHand)
{
handPosition = leftHand;
}
else
{
handPosition = rightHand;
}
handPosition.parent = null;
handPosition.position = lockPosition.transform.position;
selected = true;
}
base.OnSelectEnter(interactor);
}
private void GetMag()
{
if (player.ammoCount > 0)
{
if (interactor && !interactor.selectTarget && interactor.GetComponent <XRController>().inputDevice.TryGetFeatureValue(CommonUsages.grip, out float gripValue) && gripValue >= 0.7 && initTime <= Time.time)
{
if (interactor == player.right && player.left.selectTarget)
{
var temp = Instantiate(CheckMag(player.left.selectTarget.GetComponentInChildren <XRSocketInteractorWithName>().targetName), interactor.transform.position, interactor.transform.rotation);
var tempMag = temp?.GetComponent <Magazine>();
if (tempMag.fullAmmo > player.ammoCount)
{
tempMag.ammoCount = player.ammoCount;
player.ammoCount = 0;
}
else
{
tempMag.ammoCount = tempMag.fullAmmo;
player.ammoCount -= tempMag.fullAmmo;
}
initTime = Time.time + delay;
}
else if (interactor == player.left && player.right.selectTarget)
{
var temp = Instantiate(CheckMag(player.right.selectTarget.GetComponentInChildren <XRSocketInteractorWithName>().targetName), interactor.transform.position, interactor.transform.rotation);
var tempMag = temp?.GetComponent <Magazine>();
if (tempMag.fullAmmo > player.ammoCount)
{
tempMag.ammoCount = player.ammoCount;
player.ammoCount = 0;
}
else
{
tempMag.ammoCount = tempMag.fullAmmo;
player.ammoCount -= tempMag.fullAmmo;
}
initTime = Time.time + delay;
}
}
}
}
protected override void OnSelectEnter(XRBaseInteractor interactor)
{
base.OnSelectEnter(interactor);
attachedController = interactor.GetComponent <XRController>();
}
//PROCEDURE ON GRIP RELEASE
protected override void OnDeactivate(XRBaseInteractor interactor)
{
if (interactor.GetComponent <XRController>().controllerNode == handController)
{
base.OnDeactivate(interactor);
MatchAttachmentPoints(interactor);
if (selected)
{
audioSelectFlag = true;
audioActivateFlag = false;
if (this.gameObject.tag != "Duplicate")
{
adjustQuadScript.SetAdjustListen(false);
}
quadMaterial.SetColor(outlineColorName, selectColorForHandMode);
}
else
{
audioSelectFlag = false;
audioActivateFlag = false;
if (this.gameObject.tag != "Duplicate")
{
moveLocomotionScript.moveSpeed = inactiveMoveSpeed;
adjustQuadScript.SetAdjustListen(true);
}
quadMaterial.SetColor(outlineColorName, inactiveColor);
}
base.trackRotation = false;
base.trackPosition = true;
}
else if (interactor.GetComponent <XRController>().controllerNode == joystickController)
{
if (selected)
{
audioSelectFlag = true;
audioActivateFlag = false;
rotateQuadScript.SetTranslate(true);
rotateQuadScript.SetRotate(false);
if (this.gameObject.tag != "Duplicate")
{
adjustQuadScript.SetAdjustListen(false);
}
quadMaterial.SetColor(outlineColorName, selectColorForJoystickMode);
}
else
{
audioSelectFlag = false;
audioActivateFlag = false;
rotateQuadScript.SetTranslate(false);
rotateQuadScript.SetRotate(false);
if (this.gameObject.tag != "Duplicate")
{
adjustQuadScript.SetAdjustListen(true);
}
quadMaterial.SetColor(outlineColorName, inactiveColor);
}
}
}
private void OnBeginInteraction(XRBaseInteractor interactor)
{
currentInteractorTransform = interactor.transform;
interactor.GetComponent <XRBaseController>().hideControllerModel = true;
proxyHand.Activate();
}
public void OnRelease(XRBaseInteractor interactor)
{
interactor.GetComponent <XRBaseController>().hideControllerModel = false;
ChangePose(HandPoses.NoPose, interactor);
}
public void OnGrab(XRBaseInteractor interactor)
{
interactor.GetComponent <XRBaseController>().hideControllerModel = hideController;
ChangePose(interactionPose, interactor);
}
public IEnumerator ContactInteractorTargetStaysValidWhenTouchingAnyCollider([ValueSource(nameof(s_ContactInteractors))] Type interactorType)
{
// This tests that an Interactable will stay as a valid target as long as
// the Direct and Socket Interactor is touching any Collider associated with the Interactable,
// and remains so if only some (but not all) of the Interactable colliders leaves.
var manager = TestUtilities.CreateInteractionManager();
XRBaseInteractor interactor = null;
if (interactorType == typeof(XRDirectInteractor))
{
interactor = TestUtilities.CreateDirectInteractor();
}
else if (interactorType == typeof(XRSocketInteractor))
{
interactor = TestUtilities.CreateSocketInteractor();
}
Assert.That(interactor, Is.Not.Null);
var triggerCollider = interactor.GetComponent <SphereCollider>();
Assert.That(triggerCollider, Is.Not.Null);
Assert.That(triggerCollider.isTrigger, Is.True);
var interactable = TestUtilities.CreateGrabInteractable();
// Prevent the Interactable from being selected to allow the object to be moved freely
interactable.interactionLayerMask = 0;
var sphereCollider = interactable.GetComponent <SphereCollider>();
sphereCollider.center = Vector3.zero;
sphereCollider.radius = 0.5f;
Assert.That(sphereCollider, Is.Not.Null);
interactable.transform.position = Vector3.forward * 10f;
// Create another Collider to have as part of the Interactable
var boxColliderTransform = new GameObject("Box Collider", typeof(BoxCollider)).transform;
boxColliderTransform.SetParent(interactable.transform);
boxColliderTransform.localPosition = Vector3.right;
boxColliderTransform.localRotation = Quaternion.identity;
var boxCollider = boxColliderTransform.GetComponent <BoxCollider>();
boxCollider.center = Vector3.zero;
boxCollider.size = Vector3.one;
interactable.colliders.Clear();
interactable.colliders.Add(sphereCollider);
interactable.colliders.Add(boxCollider);
interactable.enabled = false;
interactable.enabled = true;
Assert.That(manager.GetInteractableForCollider(sphereCollider), Is.EqualTo(interactable));
Assert.That(manager.GetInteractableForCollider(boxCollider), Is.EqualTo(interactable));
yield return(null);
yield return(new WaitForFixedUpdate());
var directOverlaps = Physics.OverlapSphere(triggerCollider.transform.position, triggerCollider.radius, -1, QueryTriggerInteraction.Ignore);
Assert.That(directOverlaps, Is.Empty);
var validTargets = new List <XRBaseInteractable>();
interactor.GetValidTargets(validTargets);
Assert.That(validTargets, Is.Empty);
// Move the Interactable to the Direct Interactor so that it overlaps both colliders
interactable.transform.position = Vector3.left * 0.5f;
yield return(new WaitForFixedUpdate());
yield return(null);
directOverlaps = Physics.OverlapSphere(triggerCollider.transform.position, triggerCollider.radius, -1, QueryTriggerInteraction.Ignore);
Assert.That(directOverlaps, Is.EquivalentTo(new Collider[] { sphereCollider, boxCollider }));
interactor.GetValidTargets(validTargets);
Assert.That(validTargets, Is.EqualTo(new[] { interactable }));
// Move the Interactable some so one of the colliders leaves
interactable.transform.position = Vector3.left * 2f;
yield return(new WaitForFixedUpdate());
yield return(null);
directOverlaps = Physics.OverlapSphere(triggerCollider.transform.position, triggerCollider.radius, -1, QueryTriggerInteraction.Ignore);
Assert.That(directOverlaps, Is.EquivalentTo(new Collider[] { boxCollider }));
interactor.GetValidTargets(validTargets);
Assert.That(validTargets, Is.EqualTo(new[] { interactable }));
// Move the Interactable some so the other collider is the one being hovered
// to test that colliders can re-enter after previously exiting
interactable.transform.position = Vector3.right * 1f;
yield return(new WaitForFixedUpdate());
yield return(null);
directOverlaps = Physics.OverlapSphere(triggerCollider.transform.position, triggerCollider.radius, -1, QueryTriggerInteraction.Ignore);
Assert.That(directOverlaps, Is.EquivalentTo(new Collider[] { sphereCollider }));
interactor.GetValidTargets(validTargets);
Assert.That(validTargets, Is.EqualTo(new[] { interactable }));
// Move the Interactable so all colliders exits the Direct Interactor
interactable.transform.position = Vector3.forward * 10f;
yield return(new WaitForFixedUpdate());
yield return(null);
directOverlaps = Physics.OverlapSphere(triggerCollider.transform.position, triggerCollider.radius, -1, QueryTriggerInteraction.Ignore);
Assert.That(directOverlaps, Is.Empty);
interactor.GetValidTargets(validTargets);
Assert.That(validTargets, Is.Empty);
}
public override void ProcessInteractable(XRInteractionUpdateOrder.UpdatePhase updatePhase)
{
if (updatePhase == XRInteractionUpdateOrder.UpdatePhase.Fixed)
{
if (isSelected)
{
if (selectingInteractor != null)
{
if (selectingController == null)
{
selectingController = selectingInteractor.GetComponent <XRController>();
}
if (selectingController.inputDevice.TryGetFeatureValue(CommonUsages.primary2DAxis, out Vector2 value))
{
Vector2 newValue = value;
if (Mathf.Abs(newValue.x) > joyStickInputLimit)
{
newValue.x = 1f;
if (value.x < 0f)
{
newValue.x = -newValue.x;
}
}
else
{
newValue.x = 0f;
}
if (Mathf.Abs(newValue.y) > joyStickInputLimit)
{
newValue.y = 1f;
if (value.y < 0f)
{
newValue.y = -newValue.y;
}
}
else
{
newValue.y = 0f;
}
if (newValue.x != 0f || newValue.y != 0f)
{
OnJoyStickChange(newValue);
}
float joyStickXAngle = Mathf.LerpAngle(0f, maxJoyStickAngle, Mathf.Abs(value.x));
if (value.x < 0f)
{
joyStickXAngle = -joyStickXAngle;
}
float joyStickYAngle = Mathf.LerpAngle(0f, maxJoyStickAngle, Mathf.Abs(value.y));
if (value.y < 0f)
{
joyStickYAngle = -joyStickYAngle;
}
joyStick.transform.localRotation = Quaternion.Euler(joyStickYAngle, 0f, -joyStickXAngle);
}
}
}
}
}
private void OnEndInteraction(XRBaseInteractor interactor)
{
currentInteractorTransform = null;
interactor.GetComponent <XRBaseController>().hideControllerModel = false;
proxyHand.Deactivate();
}
private void DropWeapon(XRBaseInteractor interactor)
{
interactor.GetComponent <MeshHider>().Show();
}
private void PickUpWeapon(XRBaseInteractor interactor)
{
interactor.GetComponent <MeshHider>().Hide();
}
