public void ResetFocusedObjects()
{
PreviousEndObject = null;
End = new FocusDetails
{
Point = End.Point,
Normal = End.Normal,
Object = null
};
}
public void UpdateHit(RaycastResult uiHit)
{
PreviousEndObject = End.Object;
StartPoint = PointingSource.Ray.origin;
End = new FocusDetails
{
Point = uiHit.worldPosition,
Normal = uiHit.worldNormal,
Object = uiHit.gameObject,
};
}
public void UpdateHit(RaycastHit physicsHit)
{
PreviousEndObject = End.Object;
StartPoint = PointingSource.Ray.origin;
End = new FocusDetails
{
Point = physicsHit.point,
Normal = physicsHit.normal,
Object = physicsHit.transform.gameObject,
};
}
/// <summary>
/// Notifies this gaze manager of its new hit details.
/// </summary>
/// <param name="focusDetails">Details of the current hit (focus).</param>
/// <param name="isRegisteredForFocus">Whether or not this gaze manager is registered as a focus pointer.</param>
public void UpdateHitDetails(FocusDetails focusDetails, bool isRegisteredForFocus)
{
HitObject = isRegisteredForFocus
? focusDetails.Object
: null; // If we're not actually registered for focus, we keep HitObject as null so we don't mislead anyone.
if (focusDetails.Object != null)
{
lastHitDistance = (focusDetails.Point - Ray.origin).magnitude;
UpdateHitPosition();
}
}
public FocusDetails GetFocusDetails(IPointingSource pointingSource)
{
PointerData pointerData;
FocusDetails details = default(FocusDetails);
if (GetPointerData(pointingSource, out pointerData))
{
details = pointerData.End;
}
return(details);
}
public void UpdateHit(float extent)
{
PreviousEndObject = End.Object;
StartPoint = PointingSource.Ray.origin;
End = new FocusDetails
{
Point = (StartPoint + (extent * PointingSource.Ray.direction)),
Normal = (-PointingSource.Ray.direction),
Object = null
};
}
public void UpdateHit(RaycastResult result, RaycastHit hit)
{
// We do not update the PreviousEndObject here because
// it's already been updated in the first physics raycast.
StartPoint = PointingSource.Ray.origin;
End = new FocusDetails
{
Point = hit.point,
Normal = hit.normal,
Object = result.gameObject
};
}
/// <summary>
/// Update the cursor's transform
/// </summary>
protected virtual void UpdateCursorTransform()
{
if (Pointer == null)
{
Debug.Log("No pointer");
return;
}
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(Pointer);
GameObject newTargetedObject = focusDetails.Object;
// Get the forward vector looking back along the pointing ray.
Vector3 lookForward = -Pointer.Ray.direction;
// Normalize scale on before update
targetScale = Vector3.one;
// If no game object is hit, put the cursor at the default distance
if (newTargetedObject == null)
{
this.TargetedObject = null;
this.TargetedCursorModifier = null;
targetPosition = Pointer.Ray.origin + Pointer.Ray.direction * DefaultCursorDistance;
targetRotation = lookForward.magnitude > 0 ? Quaternion.LookRotation(lookForward, Vector3.up) : transform.rotation;
}
else
{
// Update currently targeted object
TargetedObject = newTargetedObject;
if (TargetedCursorModifier != null)
{
TargetedCursorModifier.GetModifiedTransform(this, out targetPosition, out targetRotation, out targetScale);
}
else
{
// If no modifier is on the target, just use the hit result to set cursor position
targetPosition = focusDetails.Point + (lookForward * SurfaceCursorDistance);
targetRotation = Quaternion.LookRotation(Vector3.Lerp(focusDetails.Normal, lookForward, LookRotationBlend), Vector3.up);
}
}
float deltaTime = UseUnscaledTime
? Time.unscaledDeltaTime
: Time.deltaTime;
// Use the lerp times to blend the position to the target position
transform.position = Vector3.Lerp(transform.position, targetPosition, deltaTime / PositionLerpTime);
transform.localScale = Vector3.Lerp(transform.localScale, targetScale, deltaTime / ScaleLerpTime);
transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, deltaTime / RotationLerpTime);
}
/// <summary>
/// Update the cursor's transform
/// </summary>
protected virtual void UpdateCursorTransform()
{
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(Pointer);
GameObject newTargetedObject = focusDetails.Object;
Vector3 lookForward = Vector3.forward;
// Normalize scale on before update
targetScale = Vector3.one;
// If no game object is hit, put the cursor at the default distance
if (newTargetedObject == null)
{
TargetedObject = null;
TargetedCursorModifier = null;
targetPosition = RayStep.GetPointByDistance(Pointer.Rays, DefaultCursorDistance);
lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, DefaultCursorDistance);
targetRotation = lookForward.magnitude > 0 ? Quaternion.LookRotation(lookForward, Vector3.up) : transform.rotation;
}
else
{
// Update currently targeted object
TargetedObject = newTargetedObject;
if (TargetedCursorModifier != null)
{
TargetedCursorModifier.GetModifiedTransform(this, out targetPosition, out targetRotation, out targetScale);
}
else
{
// If no modifier is on the target, just use the hit result to set cursor position
// Get the look forward by using distance between pointer origin and target position
// (This may not be strictly accurate for extremely wobbly pointers, but it should produce usable results)
float distanceToTarget = Vector3.Distance(Pointer.Rays[0].Origin, focusDetails.Point);
lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, distanceToTarget);
targetPosition = focusDetails.Point + (lookForward * SurfaceCursorDistance);
Vector3 lookRotation = Vector3.Slerp(focusDetails.Normal, lookForward, LookRotationBlend);
targetRotation = Quaternion.LookRotation(lookRotation == Vector3.zero ? lookForward : lookRotation, Vector3.up);
}
}
float deltaTime = UseUnscaledTime
? Time.unscaledDeltaTime
: Time.deltaTime;
// Use the lerp times to blend the position to the target position
transform.position = Vector3.Lerp(transform.position, targetPosition, deltaTime / PositionLerpTime);
transform.localScale = Vector3.Lerp(transform.localScale, targetScale, deltaTime / ScaleLerpTime);
transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, deltaTime / RotationLerpTime);
}
public void UpdateHit(RaycastHit hit, RayStep sourceRay, int rayStepIndex)
{
LastRaycastHit = hit;
PreviousEndObject = End.Object;
RayStepIndex = rayStepIndex;
StartPoint = sourceRay.origin;
End = new FocusDetails
{
Point = hit.point,
Normal = hit.normal,
Object = hit.transform.gameObject
};
}
public void ResetFocusedObjects(bool clearPreviousObject = true)
{
if (clearPreviousObject)
{
PreviousEndObject = null;
}
End = new FocusDetails
{
Point = End.Point,
Normal = End.Normal,
Object = null
};
}
public void UpdateHit(RaycastResult result, RaycastHit hit, RayStep sourceRay, int rayStepIndex)
{
// We do not update the PreviousEndObject here because
// it's already been updated in the first physics raycast.
RayStepIndex = rayStepIndex;
StartPoint = sourceRay.Origin;
End = new FocusDetails
{
Point = hit.point,
Normal = hit.normal,
Object = result.gameObject
};
}
public void UpdateHit(float extent)
{
PreviousEndObject = End.Object;
RayStep firstStep = PointingSource.Rays[0];
RayStep finalStep = PointingSource.Rays[PointingSource.Rays.Length - 1];
RayStepIndex = 0;
StartPoint = firstStep.origin;
End = new FocusDetails
{
Point = finalStep.terminus,
Normal = (-finalStep.direction),
Object = null
};
}
private void PositionMarker()
{
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(currentPointingSource);
if (focusDetails.Object != null && (Vector3.Dot(focusDetails.Normal, Vector3.up) > 0.90f))
{
isTeleportValid = true;
teleportMarker.transform.position = focusDetails.Point;
}
else
{
isTeleportValid = false;
}
animationController.speed = isTeleportValid ? 1 : 0;
}
public Vector3 GetModifiedPosition(ICursor cursor)
{
Vector3 position;
if (SnapCursor)
{
// Snap if the targeted object has a cursor modifier that supports snapping
position = HostTransform.position +
HostTransform.TransformVector(CursorOffset);
}
else
{
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(cursor.Pointer);
// Else, consider the modifiers on the cursor modifier, but don't snap
position = focusDetails.Point + HostTransform.TransformVector(CursorOffset);
}
return(position);
}
private void PositionMarker()
{
teleportMarker.SetActive(true);
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(currentPointingSource);
Vector3 telePos = Vector3.zero;
// Check if what is pointed at could be warped to.
if (focusDetails.Object != null && (Vector3.Dot(focusDetails.Normal, Vector3.up) > 0.90f))
{
isTeleportValid = true;
telePos = focusDetails.Point;
}
else
{
// If we can't warp straight ahead, try drawing an arc like we do in the shell.
isTeleportValid = TryReallyHardToFindATeleportPoint(out telePos);
}
teleportMarker.transform.position = telePos;
animationController.speed = isTeleportValid ? 1 : 0;
SetArcLines();
}
/// <summary>
/// Update the cursor's transform
/// </summary>
protected virtual void UpdateCursorTransform()
{
FocusDetails focusDetails = FocusManager.Instance.GetFocusDetails(Pointer);
GameObject newTargetedObject = focusDetails.Object;
Vector3 lookForward = Vector3.forward;
// Normalize scale on before update
targetScale = Vector3.one;
// If no game object is hit, put the cursor at the default distance
if (newTargetedObject == null)
{
TargetedObject = null;
TargetedCursorModifier = null;
if (pointerIsInputSourcePointer)
{
// This value get re-queried every update, in case the app has
// changed the pointing extent of the pointer for the current scenario.
float distance = FocusManager.Instance.GetPointingExtent(Pointer);
if (DefaultCursorDistance != distance)
{
DefaultCursorDistance = distance;
}
}
else if (DefaultCursorDistance != originalDefaultCursorDistance)
{
DefaultCursorDistance = originalDefaultCursorDistance;
}
targetPosition = RayStep.GetPointByDistance(Pointer.Rays, DefaultCursorDistance);
lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, DefaultCursorDistance);
targetRotation = lookForward.magnitude > 0
? Quaternion.LookRotation(lookForward, Vector3.up)
: transform.rotation;
}
else
{
// Update currently targeted object
TargetedObject = newTargetedObject;
if (TargetedCursorModifier != null)
{
TargetedCursorModifier.GetModifiedTransform(this, out targetPosition, out targetRotation,
out targetScale);
}
else
{
// If no modifier is on the target, just use the hit result to set cursor position
// Get the look forward by using distance between pointer origin and target position
// (This may not be strictly accurate for extremely wobbly pointers, but it should produce usable results)
float distanceToTarget = Vector3.Distance(Pointer.Rays[0].Origin, focusDetails.Point);
lookForward = -RayStep.GetDirectionByDistance(Pointer.Rays, distanceToTarget);
targetPosition = focusDetails.Point + (lookForward * SurfaceCursorDistance);
Vector3 lookRotation = Vector3.Slerp(focusDetails.Normal, lookForward, LookRotationBlend);
targetRotation = Quaternion.LookRotation(lookRotation == Vector3.zero ? lookForward : lookRotation,
Vector3.up);
}
}
UpdateAndSync(targetPosition, targetScale, targetRotation);
}