//-------------------------------------------------
public void ArrowReleased()
{
nocked = false;
hand.HoverUnlock(GetComponent <VRTRIXInteractable>());
hand.otherHand.HoverUnlock(arrowHand.GetComponent <VRTRIXInteractable>());
if (releaseSound != null)
{
releaseSound.Play();
}
this.StartCoroutine(this.ResetDrawAnim());
}
//-------------------------------------------------
private void HidePointer()
{
if (visible)
{
pointerHideStartTime = Time.time;
}
visible = false;
if (pointerHand)
{
if (ShouldOverrideHoverLock())
{
//Restore the original hovering interactable on the hand
if (originalHoverLockState == true)
{
pointerHand.HoverLock(originalHoveringInteractable);
}
else
{
pointerHand.HoverUnlock(null);
}
}
//Stop looping sound
loopingAudioSource.Stop();
PlayAudioClip(pointerAudioSource, pointerStopSound);
}
teleportPointerObject.SetActive(false);
teleportArc.Hide();
foreach (VRTRIXTeleportMarkerBase teleportMarker in teleportMarkers)
{
if (teleportMarker != null && teleportMarker.markerActive && teleportMarker.gameObject != null)
{
teleportMarker.gameObject.SetActive(false);
}
}
destinationReticleTransform.gameObject.SetActive(false);
invalidReticleTransform.gameObject.SetActive(false);
offsetReticleTransform.gameObject.SetActive(false);
if (playAreaPreviewTransform != null)
{
playAreaPreviewTransform.gameObject.SetActive(false);
}
if (onActivateObjectTransform.gameObject.activeSelf)
{
onActivateObjectTransform.gameObject.SetActive(false);
}
onDeactivateObjectTransform.gameObject.SetActive(true);
pointerHand = null;
}
//-------------------------------------------------
private void OnDetachedFromHand(VRTRIXGloveGrab hand)
{
attached = false;
onDetachFromHand.Invoke();
hand.HoverUnlock(null);
Rigidbody rb = GetComponent <Rigidbody>();
rb.isKinematic = false;
rb.interpolation = RigidbodyInterpolation.Interpolate;
Vector3 position = Vector3.zero;
Vector3 velocity = Vector3.zero;
Vector3 angularVelocity = Vector3.zero;
//if (hand.controller == null)
//{
velocityEstimator.FinishEstimatingVelocity();
velocity = velocityEstimator.GetVelocityEstimate();
angularVelocity = velocityEstimator.GetAngularVelocityEstimate();
position = velocityEstimator.transform.position;
//}
//else
//{
// velocity = Player.instance.trackingOriginTransform.TransformVector(hand.controller.velocity);
// angularVelocity = Player.instance.trackingOriginTransform.TransformVector(hand.controller.angularVelocity);
// position = hand.transform.position;
//}
Vector3 r = transform.TransformPoint(rb.centerOfMass) - position;
rb.velocity = velocity + Vector3.Cross(angularVelocity, r);
rb.angularVelocity = angularVelocity;
// Make the object travel at the release velocity for the amount
// of time it will take until the next fixed update, at which
// point Unity physics will take over
float timeUntilFixedUpdate = (Time.fixedDeltaTime + Time.fixedTime) - Time.time;
transform.position += timeUntilFixedUpdate * velocity;
float angle = Mathf.Rad2Deg * angularVelocity.magnitude;
Vector3 axis = angularVelocity.normalized;
transform.rotation *= Quaternion.AngleAxis(angle * timeUntilFixedUpdate, axis);
}
private IEnumerator LateDetach(VRTRIXGloveGrab hand)
{
yield return(new WaitForEndOfFrame());
//Debug.Log(hand.currentAttachedObject);
if (hand.currentAttachedObject == gameObject)
{
// Detach this object from the hand
hand.DetachObject(gameObject);
// Call this to undo HoverLock
hand.HoverUnlock(GetComponent <VRTRIXInteractable>());
isHoveredbyHand = false;
}
// hand.DetachObject(gameObject);
}
private IEnumerator LateDetach(VRTRIXGloveGrab hand)
{
yield return(new WaitForEndOfFrame());
//Debug.Log(hand.currentAttachedObject);
if (hand.currentAttachedObject == gameObject)
{
// Detach this object from the hand
hand.DetachObject(gameObject);
// Call this to undo HoverLock
hand.HoverUnlock(GetComponent <VRTRIXInteractable>());
// Restore position/rotation
transform.position = oldPosition;
transform.rotation = oldRotation;
}
// hand.DetachObject(gameObject);
}
//-------------------------------------------------
private void HandAttachedUpdate(VRTRIXGloveGrab hand)
{
if (bow == null)
{
FindBow();
}
if (bow == null)
{
return;
}
if (allowArrowSpawn && (currentArrow == null)) // If we're allowed to have an active arrow in hand but don't yet, spawn one
{
currentArrow = InstantiateArrow();
arrowSpawnSound.Play();
}
float distanceToNockPosition = Vector3.Distance(transform.parent.position, bow.nockTransform.position);
// If there's an arrow spawned in the hand and it's not nocked yet
if (!nocked)
{
// If we're close enough to nock position that we want to start arrow rotation lerp, do so
if (distanceToNockPosition < rotationLerpThreshold)
{
float lerp = Util.RemapNumber(distanceToNockPosition, rotationLerpThreshold, lerpCompleteDistance, 0, 1);
arrowNockTransform.rotation = Quaternion.Lerp(arrowNockTransform.parent.rotation, bow.nockRestTransform.rotation, lerp);
}
else // Not close enough for rotation lerp, reset rotation
{
arrowNockTransform.localRotation = Quaternion.identity;
}
// If we're close enough to the nock position that we want to start arrow position lerp, do so
if (distanceToNockPosition < positionLerpThreshold)
{
float posLerp = Util.RemapNumber(distanceToNockPosition, positionLerpThreshold, lerpCompleteDistance, 0, 1);
posLerp = Mathf.Clamp(posLerp, 0f, 1f);
arrowNockTransform.position = Vector3.Lerp(arrowNockTransform.parent.position, bow.nockRestTransform.position, posLerp);
}
else // Not close enough for position lerp, reset position
{
arrowNockTransform.position = arrowNockTransform.parent.position;
}
// Give a haptic tick when lerp is visually complete
if (distanceToNockPosition < lerpCompleteDistance)
{
if (!arrowLerpComplete)
{
arrowLerpComplete = true;
//hand.controller.TriggerHapticPulse(500);
}
}
else
{
if (arrowLerpComplete)
{
arrowLerpComplete = false;
}
}
// Allow nocking the arrow when controller is close enough
if (distanceToNockPosition < nockDistance)
{
if (!inNockRange)
{
inNockRange = true;
bow.ArrowInPosition();
}
}
else
{
if (inNockRange)
{
inNockRange = false;
}
}
// If arrow is close enough to the nock position and we're pressing the trigger, and we're not nocked yet, Nock
if ((distanceToNockPosition < nockDistance) && hand.GetStandardInteractionButtonDown() && !nocked)
{
if (currentArrow == null)
{
currentArrow = InstantiateArrow();
}
nocked = true;
bow.StartNock(this);
hand.HoverLock(GetComponent <VRTRIXInteractable>());
allowTeleport.teleportAllowed = false;
currentArrow.transform.parent = bow.nockTransform;
Util.ResetTransform(currentArrow.transform);
Util.ResetTransform(arrowNockTransform);
}
}
// If arrow is nocked, and we release the trigger
if (nocked && (!hand.GetStandardInteractionButtonDown()))
{
if (bow.pulled) // If bow is pulled back far enough, fire arrow, otherwise reset arrow in arrowhand
{
FireArrow();
}
else
{
arrowNockTransform.rotation = currentArrow.transform.rotation;
currentArrow.transform.parent = arrowNockTransform;
Util.ResetTransform(currentArrow.transform);
nocked = false;
bow.ReleaseNock();
hand.HoverUnlock(GetComponent <VRTRIXInteractable>());
allowTeleport.teleportAllowed = true;
}
bow.StartRotationLerp(); // Arrow is releasing from the bow, tell the bow to lerp back to controller rotation
}
}
//-------------------------------------------------
private void ShowPointer(VRTRIXGloveGrab newPointerHand, VRTRIXGloveGrab oldPointerHand)
{
if (!visible)
{
pointedAtTeleportMarker = null;
pointerShowStartTime = Time.time;
visible = true;
meshFading = true;
teleportPointerObject.SetActive(false);
teleportArc.Show();
foreach (VRTRIXTeleportMarkerBase teleportMarker in teleportMarkers)
{
if (teleportMarker.markerActive && teleportMarker.ShouldActivate(player.feetPositionGuess))
{
teleportMarker.gameObject.SetActive(true);
teleportMarker.Highlight(false);
}
}
startingFeetOffset = player.trackingOriginTransform.position - player.feetPositionGuess;
movedFeetFarEnough = false;
if (onDeactivateObjectTransform.gameObject.activeSelf)
{
onDeactivateObjectTransform.gameObject.SetActive(false);
}
onActivateObjectTransform.gameObject.SetActive(true);
loopingAudioSource.clip = pointerLoopSound;
loopingAudioSource.loop = true;
loopingAudioSource.Play();
loopingAudioSource.volume = 0.0f;
}
if (oldPointerHand)
{
if (ShouldOverrideHoverLock())
{
//Restore the original hovering interactable on the hand
if (originalHoverLockState == true)
{
oldPointerHand.HoverLock(originalHoveringInteractable);
}
else
{
oldPointerHand.HoverUnlock(null);
}
}
}
pointerHand = newPointerHand;
if (visible && oldPointerHand != pointerHand)
{
PlayAudioClip(pointerAudioSource, pointerStartSound);
}
if (pointerHand)
{
pointerStartTransform = GetPointerStartTransform(pointerHand);
//print(pointerStartTransform);
if (pointerHand.currentAttachedObject != null)
{
allowTeleportWhileAttached = pointerHand.currentAttachedObject.GetComponent <VRTRIXAllowTeleportWhileAttachedToHand>();
}
//Keep track of any existing hovering interactable on the hand
originalHoverLockState = pointerHand.hoverLocked;
originalHoveringInteractable = pointerHand.hoveringInteractable;
if (ShouldOverrideHoverLock())
{
pointerHand.HoverLock(null);
}
pointerAudioSource.transform.SetParent(pointerStartTransform);
pointerAudioSource.transform.localPosition = Vector3.zero;
loopingAudioSource.transform.SetParent(pointerStartTransform);
loopingAudioSource.transform.localPosition = Vector3.zero;
}
}
