public virtual void OnSlowFrame(VrEventInfo processedVrEventInfo)
{
if (timerRunning)
{
ControllerInput.Instance.SetHudTime(timeRemaining / timeToCompleteActivity, timeRemaining);
}
}
public override void OnTriggerClickDown(VrEventInfo info)
{
base.OnTriggerClickDown(info);
baseRotation = transform.rotation.eulerAngles;
baseRotationController = info.ControllerRotation.eulerAngles;
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
base.OnFrame(processedVrEventInfo);
if (finished)
{
return;
}
switch (processedVrEventInfo.EventType)
{
case VrEventInfo.VrEventType.TriggerDown:
case VrEventInfo.VrEventType.TouchpadClickDown:
if (!started)
{
started = true;
if (dismissOnAction)
{
if (infoPanel && !introOnly)
{
infoPanel.Show(false);
}
}
if (timeToCompleteActivity > 0f)
{
StartTimer();
}
}
break;
}
}
/// <summary>
/// Forwarded by ActivityManager to the current
/// activity
/// </summary>
/// <param name="info"></param>
public virtual void OnFrame(VrEventInfo processedVrEventInfo)
{
if (currentState)
{
currentState.OnFrame(processedVrEventInfo);
}
}
public virtual void OnTriggerClickDown(VrEventInfo info)
{
triggerDown = true;
clickdownOffset = info.PointerTarget - transform.position;
if (rolloverPrompt)
{
rolloverPrompt.SetActive(false);
}
if (sharedInfo && clickdownTextData.Usable())
{
sharedInfo.SetText(clickdownTextData);
}
textReceiver?.ReceiveClickdownText(clickdownTextData);
if (clickdownPrompt)
{
clickdownPrompt.SetActive(true);
if (!promptsFixed)
{
Utils.FaceCamera(clickdownPrompt.transform, ControllerInput.Instance.Player);
}
clickdownTimer = 0f;
}
ClickDownEffect();
clickDownAction?.Invoke(this);
}
public virtual void OnTriggerClickUp(VrEventInfo info)
{
triggerDown = false;
if (clickdownPrompt)
{
clickdownPrompt.SetActive(false);
}
if (sharedInfo)
{
sharedInfo.Show(false);
}
textReceiver?.ReceiveClickdownText(null);
if (attachedJoint)
{
attachedJoint.connectedBody = null;
attachedJoint = null;
}
ClickUpEffect();
clickUpAction?.Invoke(this);
}
/// <summary>
/// This message may come directly from ControllerInput
/// or may be processed by an intermediary
/// </summary>
/// <param name="info"></param>
public void OnFrame(VrEventInfo processedVrEventInfo)
{
if (CurrentActivity)
{
CurrentActivity.OnFrame(processedVrEventInfo);
}
}
/// <summary>
/// For a more analogue feel. Works 4-way continuous,
/// bit a bit hard to control. And probably don't need
/// or want strafing
/// </summary>
/// <param name="processedVrEventInfo"></param>
/// <returns></returns>
public static bool HandleUserNavigation(VrEventInfo processedVrEventInfo, out Vector3 targetPoint, out float travelAngle, out Vector3 guidePoint)
{
Vector3 controllerDir = processedVrEventInfo.ControllerDirection.normalized;
float dot = Vector3.Dot(controllerDir, Vector3.up);
travelAngle = 0f;
guidePoint = Vector3.zero;
targetPoint = Vector3.zero;
if (dot > -.75f && dot < .75f) // Originally .5f
{
Vector3 playerPos = ControllerInput.Instance.PlayerRb.position;
travelAngle = GetTravelAngle(processedVrEventInfo);
Debug.Log("Travel angle: " + travelAngle);
guidePoint = processedVrEventInfo.ControllerPosition + Quaternion.AngleAxis(travelAngle, Vector3.up) * controllerDir * 2f;
guidePoint.y = playerPos.y;
targetPoint = Vector3.MoveTowards(playerPos, guidePoint, ActivitySettings.Asset.playerSpeed * Time.fixedDeltaTime);
return(true);
}
else
{
return(false);
}
}
public virtual void PushPull(VrEventInfo processedVrEventInfo)
{
if (!processedVrEventInfo.TouchIsDown)
{
processedVrEventInfo.BeamDistance += (processedVrEventInfo.TouchpadMoved.y * Time.deltaTime * ActivitySettings.Asset.beamExtensionSpeed);
processedVrEventInfo.BeamDistance = Mathf.Clamp(processedVrEventInfo.BeamDistance, ActivitySettings.Asset.minBeamLength, ActivitySettings.Asset.maxBeamLength);
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (OnClick != null)
{
OnClick(this);
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (switchGrid)
{
switchGrid.OnChildSelection?.Invoke(this);
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (pointerWithin)
{
ueResponse?.Invoke();
response?.Invoke(ourIndex);
}
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
SetControllerOrientation(processedVrEventInfo.ControllerPosition, processedVrEventInfo.ControllerRotation);
SetReticlePosition(processedVrEventInfo.HoldingTargetPosition);
AlignReticleToCamera();
Draw();
}
public override void OnTriggerClickDown(VrEventInfo info)
{
base.OnTriggerClickDown(info);
baseRotation = transform.rotation.eulerAngles;
baseRotationController = info.ControllerRotation.eulerAngles;
rotationAccum = 0f;
previousAngle = baseRotationController.z;
}
/// <summary>
/// First check there's no x,y == 0,0 touchpad reading
/// before calling this
/// </summary>
/// <param name="processedVrEventInfo"></param>
/// <returns></returns>
public static float GetTravelAngle(VrEventInfo processedVrEventInfo)
{
double theta = Mathf.Atan2(processedVrEventInfo.TouchpadPosition.x, processedVrEventInfo.TouchpadPosition.y);
if (theta < 0.0)
{
theta += TWOPI;
}
return((float)(RAD2DEG * theta));
}
public override void Handle(VrEventInfo info)
{
if (interactionDispatcher)
{
info = interactionDispatcher.DispatchInteraction(info);
}
if (beamPointer)
{
beamPointer.OnFrame(info);
}
}
public static Vector3 GetOneAxisMovement(VrEventInfo processedVrEventInfo)
{
Vector3 controllerDir = processedVrEventInfo.ControllerDirection.normalized;
Vector3 playerPos = ControllerInput.Instance.PlayerRb.position;
Vector3 targetPoint = playerPos + controllerDir * ActivitySettings.Asset.playerSpeed;
targetPoint.y = playerPos.y;
return(targetPoint);
}
/// <summary>
/// Looks for any objects of interest and
/// sets RaycastHitPosition, which will either
/// correspond with the raycast hit point
/// or the end of the beam of specificed
/// length
/// </summary>
private VrEventInfo UpdateRaycaster(VrEventInfo vrEventInfo)
{
vrEventInfo.PrevHitObject = vrEventInfo.HitObject;
vrEventInfo.genericHitObject = null;
#if USING_UUI
if (CheckUiObjects(ref vrEventInfo))
{
vrEventInfo.RaycastHit = true; // Do we need a separate UI cast hit flag? Probably not, as we're only interested in positioning the reticle
vrEventInfo.RaycastNormal = -vrEventInfo.UiTargetGameObject.transform.forward;
vrEventInfo.HitObject = null;
}
else
#endif
bool gotHit = false;
if (Physics.RaycastNonAlloc(vrEventInfo.ControllerPosition, vrEventInfo.ControllerDirection, physicsRaycasts,
ActivitySettings.Asset.raycastDistance, ActivitySettings.Asset.interactableTarget) > 0)
{
gotHit = true;
Graspable hitObject = physicsRaycasts[0].transform.gameObject.GetComponent <Graspable>();
if (!hitObject) // This might be a child 'trap' for a raycast such as a label
{
hitObject = physicsRaycasts[0].transform.gameObject.GetComponentInParent <Graspable>();
}
// Ignore anything with a Graspable that's marked as dormant
if (hitObject && hitObject.Dormant)
{
gotHit = false;
}
if (gotHit)
{
vrEventInfo.RaycastHit = true;
vrEventInfo.RaycastHitPosition = physicsRaycasts[0].point;
vrEventInfo.RaycastNormal = physicsRaycasts[0].normal;
vrEventInfo.BeamDistance = physicsRaycasts[0].distance;
vrEventInfo.PointerDotWithUp = Vector3.Dot(vrEventInfo.ControllerDirection, Vector3.up);
vrEventInfo.HitObject = hitObject;
vrEventInfo.genericHitObject = physicsRaycasts[0].transform.gameObject;
}
}
if (!gotHit)
{
vrEventInfo.RaycastHit = false;
vrEventInfo.RaycastHitPosition = vrEventInfo.ControllerPosition + vrEventInfo.ControllerDirection * ActivitySettings.Asset.raycastDistance;
vrEventInfo.BeamDistance = ActivitySettings.Asset.raycastDistance;
vrEventInfo.HitObject = null;
}
return(vrEventInfo);
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
base.OnFrame(processedVrEventInfo);
switch (processedVrEventInfo.EventType)
{
case VrEventInfo.VrEventType.TriggerDown:
case VrEventInfo.VrEventType.TouchpadClickDown:
StartTimer();
break;
}
}
public override void OnTriggerClickDown(VrEventInfo info)
{
base.OnTriggerClickDown(info);
Utils.FaceCamera(transform);
baseRotation = transform.rotation.eulerAngles;
baseRotationController = info.ControllerRotation.eulerAngles;
Debug.LogFormat("Base rotation pourable: {0}. Base rotation controller: {1}", baseRotation, baseRotationController);
isSelected = true;
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (animator)
{
animator.SetTrigger(clickUpTrigger);
}
if (OnClick != null)
{
OnClick(this);
}
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
base.OnFrame(processedVrEventInfo);
switch (processedVrEventInfo.EventType)
{
case VrEventInfo.VrEventType.TriggerDown:
break;
default:
break;
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (returnOnRelease)
{
transform.position = initialPos; // TODO: animate this
}
audioLooper.Stop();
if (mopEffect)
{
mopEffect.SetMode(false);
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (PouringComplete != null)
{
PouringComplete(this, targetedPourTotal);
}
baseRotation = transform.rotation.eulerAngles;
isSelected = false;
SetPour(false);
}
public override void OnSlowFrame(VrEventInfo processedVrEventInfo)
{
if (complete)
{
return;
}
if (Done() && !scored)
{
scored = true;
complete = true;
continueButton.Activate(scoreText, BringInChef);
}
}
public override void OnTriggerClickUp(VrEventInfo info)
{
base.OnTriggerClickUp(info);
if (pointerWithin && clickUpEvent != null)
{
clickUpEvent.Invoke();
}
if (trigger != null)
{
trigger();
}
timedAction = null;
}
/// <summary>
/// Process status of Graspable
/// </summary>
/// <param name="hitObject"></param>
protected virtual VrEventInfo CheckGrabbableObject(VrEventInfo vrEventInfo)
{
if (!vrEventInfo.HitObject)
{
if (vrEventInfo.PrevHitObject)
{
vrEventInfo.PrevHitObject.OnPointerExit();
vrEventInfo.PrevHitObject.Clear();
vrEventInfo.PrevHitObject = null;
vrEventInfo.TargetObjectStatus = VrEventInfo.VrTargetObjectStatus.Unhighlighted;
}
}
else
{
if (vrEventInfo.HitObject != vrEventInfo.PrevHitObject)
{
if (vrEventInfo.PrevHitObject)
{
vrEventInfo.PrevHitObject.OnPointerExit();
vrEventInfo.PrevHitObject.Clear();
vrEventInfo.PrevHitObject = null;
}
bool okHit = false;
if (vrEventInfo.HitObject)
{
if (vrEventInfo.HitObject.IsA <Teleportable>())
{
if (vrEventInfo.PointerDotWithUp >= ActivitySettings.Asset.minimumAngleForTeleport)
{
okHit = true;
}
}
else
{
okHit = true;
}
}
if (okHit)
{
vrEventInfo.HitObject.OnPointerEnter();
vrEventInfo.TargetObjectStatus = VrEventInfo.VrTargetObjectStatus.Highlighted;
}
}
}
return(vrEventInfo);
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
SetControllerOrientation(processedVrEventInfo.ControllerPosition, processedVrEventInfo.ControllerRotation);
SetReticlePosition(processedVrEventInfo.ControllerPosition.AbsoluteLerp(processedVrEventInfo.RaycastHitPosition, ActivitySettings.Asset.inset));
if (processedVrEventInfo.RaycastHit)
{
SetReticleOrientation(processedVrEventInfo.RaycastNormal);
}
else
{
AlignReticleToCamera();
}
Draw(true, processedVrEventInfo.RaycastHit || ActivitySettings.Asset.showReticleAlways);
}
public virtual void ProcessGrabbedObject(VrEventInfo processedVrEventInfo)
{
if (processedVrEventInfo.GrabbedObject)
{
processedVrEventInfo.GrabbedObject.UpdateRotation(processedVrEventInfo.ControllerRotation);
if (processedVrEventInfo.TouchIsTouched)
{
PushPull(processedVrEventInfo);
}
Vector3 newPos = processedVrEventInfo.PointerTarget;
processedVrEventInfo.GrabbedObject.MoveTo(newPos);
processedVrEventInfo.HoldingTargetPosition = newPos;
}
}
public override void OnFrame(VrEventInfo processedVrEventInfo)
{
base.OnFrame(processedVrEventInfo);
switch (processedVrEventInfo.EventType)
{
case VrEventInfo.VrEventType.TriggerDown:
break;
}
if (newCable)
{
Vector3 cableDest = ControllerInput.Instance.ControllerPosition +
ControllerInput.Instance.ControllerDirection * beamLengthAtTerminal;
newCable.UpdateConnection(cableDest);
}
}
