protected virtual float CastRayForward()
{
Transform origin = GetOrigin();
if (origin == null)
{
return(0);
}
Ray pointerRaycast = new Ray(origin.position, origin.forward);
RaycastHit pointerCollidedWith;
bool rayHit = VRTK_CustomRaycast.Raycast(customRaycast, pointerRaycast, out pointerCollidedWith, defaultIgnoreLayer, maximumLength);
CheckRayMiss(rayHit, pointerCollidedWith);
CheckRayHit(rayHit, pointerCollidedWith);
float actualLength = maximumLength;
if (rayHit && pointerCollidedWith.distance < maximumLength)
{
actualLength = pointerCollidedWith.distance;
}
return(OverrideBeamLength(actualLength));
}
protected virtual void CalculateLean(Vector3 startPosition, float forwardLength, float originalRayDistance)
{
//Cast the new down ray based on the position of the end of the forward ray but still at a flat plane of the headset forward (i.e. no headset rotation)
Vector3 rayDownStartPosition = startPosition + (headset.forward * forwardLength);
rayDownStartPosition = new Vector3(rayDownStartPosition.x, startPosition.y, rayDownStartPosition.z);
Ray downRay = new Ray(rayDownStartPosition, -playArea.up);
RaycastHit downRayCollision;
//Cast a ray down from the end of the forward ray position
#pragma warning disable 0618
if (VRTK_CustomRaycast.Raycast(customRaycast, downRay, out downRayCollision, layersToIgnore, Mathf.Infinity))
#pragma warning restore 0618
{
//Determine the difference between the original down ray and the projected forward a bit downray
float rayDownDelta = VRTK_SharedMethods.RoundFloat(originalRayDistance - downRayCollision.distance, decimalPrecision);
//Determine the difference between the current play area position and the last play area position
float playAreaPositionDelta = VRTK_SharedMethods.RoundFloat(Vector3.Distance(playArea.transform.position, lastPlayAreaPosition), decimalPrecision);
//If the play area is not moving and the delta between the down rays is greater than 0 then you're probably walking forward over something you can stand on
isMoving = (onGround && playAreaPositionDelta <= playAreaPositionThreshold && rayDownDelta > 0f ? true : isMoving);
//If the item your standing over is too high to walk on top of then allow leaning over it.
isLeaning = (onGround && rayDownDelta > leanYThreshold ? true : false);
}
}
protected virtual Vector3 ProjectDownBeam(Vector3 jointPosition)
{
Vector3 downPosition = Vector3.zero;
Ray projectedBeamDownRaycast = new Ray(jointPosition, Vector3.down);
RaycastHit collidedWith;
bool downRayHit = VRTK_CustomRaycast.Raycast(customRaycast, projectedBeamDownRaycast, out collidedWith, layersToIgnore, float.PositiveInfinity);
if (!downRayHit || (destinationHit.collider && destinationHit.collider != collidedWith.collider))
{
if (destinationHit.collider != null)
{
PointerExit(destinationHit);
}
destinationHit = new RaycastHit();
downPosition = projectedBeamDownRaycast.GetPoint(0f);
}
if (downRayHit)
{
downPosition = projectedBeamDownRaycast.GetPoint(collidedWith.distance);
PointerEnter(collidedWith);
destinationHit = collidedWith;
}
return(downPosition);
}
protected virtual Vector3 ProjectDownBeam(Vector3 jointPosition)
{
Vector3 downPosition = Vector3.zero;
Ray projectedBeamDownRaycast = new Ray(jointPosition, Vector3.down);
RaycastHit collidedWith;
#pragma warning disable 0618
bool downRayHit = VRTK_CustomRaycast.Raycast(customRaycast, projectedBeamDownRaycast, out collidedWith, layersToIgnore, maximumLength.y);
#pragma warning restore 0618
if (!downRayHit || (destinationHit.collider && destinationHit.collider != collidedWith.collider))
{
if (destinationHit.collider != null)
{
PointerExit(destinationHit);
}
destinationHit = new RaycastHit();
downPosition = projectedBeamDownRaycast.GetPoint(0f);
}
if (downRayHit)
{
downPosition = projectedBeamDownRaycast.GetPoint(collidedWith.distance);
PointerEnter(collidedWith);
destinationHit = collidedWith;
}
return(downPosition);
}
protected virtual float CastRayForward()
{
Transform origin = GetOrigin();
Ray pointerRaycast = new Ray(origin.position, origin.forward);
RaycastHit pointerCollidedWith;
bool rayHit = VRTK_CustomRaycast.Raycast(customRaycast, pointerRaycast, out pointerCollidedWith, layersToIgnore, maximumLength);
OnGround(rayHit, pointerCollidedWith);
CheckRayMiss(rayHit, pointerCollidedWith);
CheckRayHit(rayHit, pointerCollidedWith);
// SETTING WAYPOINT
MarkGroundPoint(rayHit, pointerCollidedWith);
SelectDrone(rayHit, pointerCollidedWith);
lineSelected = SelectedLine(rayHit, pointerCollidedWith);
// SETTING WAYPOINT
//LogHeight(rayHit, pointerCollidedWith);
float actualLength = maximumLength;
if (rayHit && pointerCollidedWith.distance < maximumLength)
{
actualLength = pointerCollidedWith.distance;
}
return(OverrideBeamLength(actualLength));
}
protected virtual void CheckLean()
{
//Cast a ray down from the current standing position
Vector3 standingDownRayStartPosition = (headset ? new Vector3(currentStandingPosition.x, headset.position.y, currentStandingPosition.y) : Vector3.zero);
Vector3 rayDirection = (playArea ? -playArea.up : Vector3.zero);
Ray standingDownRay = new Ray(standingDownRayStartPosition, rayDirection);
RaycastHit standingDownRayCollision;
bool standingDownRayHit = VRTK_CustomRaycast.Raycast(customRaycast, standingDownRay, out standingDownRayCollision, layersToIgnore, Mathf.Infinity);
if (standingDownRayHit)
{
currentValidFloorObject = standingDownRayCollision.collider.gameObject;
}
//Don't bother checking for lean if body collisions are disabled
if (!headset || !playArea || !enableBodyCollisions)
{
return;
}
//reset the headset x rotation so the forward ray is always horizontal regardless of the headset rotation
Quaternion storedRotation = headset.rotation;
headset.rotation = new Quaternion(0f, headset.rotation.y, headset.rotation.z, headset.rotation.w);
float forwardLengthAddition = 0.05f;
float forwardLength = bodyCollider.radius + forwardLengthAddition;
Ray forwardRay = new Ray(headset.position, headset.forward);
RaycastHit forwardRayCollision;
// Cast a ray forward just outside the body collider radius to see if anything is blocking your path
if (!VRTK_CustomRaycast.Raycast(customRaycast, forwardRay, out forwardRayCollision, layersToIgnore, forwardLength))
{
if (standingDownRayHit)
{
Vector3 rayDownStartPosition = headset.position + headset.forward * forwardLength;
Ray downRay = new Ray(rayDownStartPosition, -playArea.up);
RaycastHit downRayCollision;
//Cast a ray down from the end of the forward ray position
if (VRTK_CustomRaycast.Raycast(customRaycast, downRay, out downRayCollision, layersToIgnore, Mathf.Infinity))
{
float distancePrecision = 1000f;
float rayDownDelta = (Mathf.Round((standingDownRayCollision.distance - downRayCollision.distance) * distancePrecision) / distancePrecision);
float playAreaPositionDelta = Mathf.Round(Vector3.Distance(playArea.transform.position, lastPlayAreaPosition) * distancePrecision) / distancePrecision;
//If the play area is not moving and the delta between the down rays is greater than 0 then you're probably walking forward over something you can stand on
isMoving = (onGround && playAreaPositionDelta <= 0.002f && rayDownDelta > 0f ? true : isMoving);
//If the item your standing over is too high to walk on top of then allow leaning over it.
isLeaning = (onGround && rayDownDelta > leanYThreshold ? true : false);
}
}
}
//put the headset rotation back
headset.rotation = storedRotation;
}
// Token: 0x06001B97 RID: 7063 RVA: 0x00090AA6 File Offset: 0x0008ECA6
public static bool Linecast(VRTK_CustomRaycast customCast, Vector3 startPosition, Vector3 endPosition, out RaycastHit hitData, LayerMask ignoreLayers, QueryTriggerInteraction affectTriggers = QueryTriggerInteraction.UseGlobal)
{
if (customCast != null)
{
return(customCast.CustomLinecast(startPosition, endPosition, out hitData));
}
return(Physics.Linecast(startPosition, endPosition, out hitData, ~ignoreLayers, affectTriggers));
}
// Token: 0x06001B98 RID: 7064 RVA: 0x00090ACD File Offset: 0x0008ECCD
public static bool CapsuleCast(VRTK_CustomRaycast customCast, Vector3 point1, Vector3 point2, float radius, Vector3 direction, float maxDistance, out RaycastHit hitData, LayerMask ignoreLayers, QueryTriggerInteraction affectTriggers = QueryTriggerInteraction.UseGlobal)
{
if (customCast != null)
{
return(customCast.CustomCapsuleCast(point1, point2, radius, direction, maxDistance, out hitData));
}
return(Physics.CapsuleCast(point1, point2, radius, direction, out hitData, maxDistance, ~ignoreLayers, affectTriggers));
}
protected virtual float ControllerHeightCheck(GameObject controllerObj)
{
Ray ray = new Ray(controllerObj.transform.position, -playArea.up);
RaycastHit rayCollidedWith;
VRTK_CustomRaycast.Raycast(customRaycast, ray, out rayCollidedWith, layersToIgnore, Mathf.Infinity);
return(controllerObj.transform.position.y - rayCollidedWith.distance);
}
// Token: 0x06001B96 RID: 7062 RVA: 0x00090A7E File Offset: 0x0008EC7E
public static bool Raycast(VRTK_CustomRaycast customCast, Ray ray, out RaycastHit hitData, LayerMask ignoreLayers, float length = float.PositiveInfinity, QueryTriggerInteraction affectTriggers = QueryTriggerInteraction.UseGlobal)
{
if (customCast != null)
{
return(customCast.CustomRaycast(ray, out hitData, length));
}
return(Physics.Raycast(ray, out hitData, length, ~ignoreLayers, affectTriggers));
}
protected override float CastRayForward()
{
Transform origin = GetOrigin();
Ray pointerRaycast = new Ray(origin.position, origin.forward);
RaycastHit pointerCollidedWith;
bool rayHit = VRTK_CustomRaycast.Raycast(customRaycast, pointerRaycast, out pointerCollidedWith, defaultIgnoreLayer, maximumLength);
CheckRayMiss(rayHit, pointerCollidedWith);
CheckRayHit(rayHit, pointerCollidedWith);
float actualLength = maximumLength;
if (rayHit && pointerCollidedWith.distance < maximumLength)
{
actualLength = pointerCollidedWith.distance;
}
//当たってる対象がAnimationWindowならマウス操作
if (rayHit && pointerCollidedWith.collider.tag == "AnimationWindow")
{
var mousePosInEditorWindow = animationWindowController.GetMousePosInEditorWindowFromUV(pointerCollidedWith.textureCoord);
if (mousePosInEditorWindow != null && editorWindowCapture != null)
{
//pointer.position = desktopPos.Value;
pointerPos = mousePosInEditorWindow.Value;
if (state == TouchState.Release)
{
//GetPointer();
//pointer.Hover();
state = TouchState.Hover;
editorWindowCapture.SendEvent(pointerPos, EventType.MouseMove);
}
else
{
editorWindowCapture.SendEvent(pointerPos, EventType.MouseDrag);
}
}
GetComponent <VRTK.VRTK_Pointer>().Toggle(true);
}
//UIに当たってればＵＩ操作
else if (uiPointer.pointerEventData.pointerEnter)
{
GetComponent <VRTK.VRTK_Pointer>().Toggle(true);
}
//AnimationWindowにもUIにも当たっていない
else
{
state = TouchState.Release;
GetComponent <VRTK.VRTK_Pointer>().Toggle(false);
GetComponent <VRTK.VRTK_Pointer>().pointerRenderer.Toggle(false, false);
}
return(OverrideBeamLength(actualLength));
}
protected virtual void AdjustForEarlyCollisions(Vector3 jointPosition, Vector3 downPosition)
{
Vector3 newDownPosition = downPosition;
Vector3 newJointPosition = jointPosition;
// Debug.Log("Exit1");
if (collisionCheckFrequency > 0 && actualTracer != null)
{
collisionCheckFrequency = Mathf.Clamp(collisionCheckFrequency, 0, tracerDensity);
Vector3[] beamPoints = new Vector3[]
{
GetOrigin().position,
jointPosition + new Vector3(0f, curveOffset, 0f),
downPosition,
downPosition,
};
Vector3[] checkPoints = actualTracer.GetPoints(beamPoints);
int checkFrequency = tracerDensity / collisionCheckFrequency;
for (int i = 0; i < tracerDensity - checkFrequency; i += checkFrequency)
{
Vector3 currentPoint = checkPoints[i];
Vector3 nextPoint = (i + checkFrequency < checkPoints.Length ? checkPoints[i + checkFrequency] : checkPoints[checkPoints.Length - 1]);
Vector3 nextPointDirection = (nextPoint - currentPoint).normalized;
float nextPointDistance = Vector3.Distance(currentPoint, nextPoint);
Ray checkCollisionRay = new Ray(currentPoint, nextPointDirection);
RaycastHit checkCollisionHit;
#pragma warning disable 0618
if (VRTK_CustomRaycast.Raycast(customRaycast, checkCollisionRay, out checkCollisionHit, layersToIgnore, nextPointDistance))
#pragma warning restore 0618
{
Vector3 collisionPoint = checkCollisionRay.GetPoint(checkCollisionHit.distance);
Ray downwardCheckRay = new Ray(collisionPoint + (Vector3.up * 0.01f), Vector3.down);
RaycastHit downwardCheckHit;
#pragma warning disable 0618
if (VRTK_CustomRaycast.Raycast(customRaycast, downwardCheckRay, out downwardCheckHit, layersToIgnore, float.PositiveInfinity))
#pragma warning restore 0618
{
destinationHit = downwardCheckHit;
newDownPosition = downwardCheckRay.GetPoint(downwardCheckHit.distance);;
newJointPosition = (newDownPosition.y < jointPosition.y ? new Vector3(newDownPosition.x, jointPosition.y, newDownPosition.z) : jointPosition);
break;
}
}
}
}
DisplayCurvedBeam(newJointPosition, newDownPosition);
SetPointerCursor();
}
/// <summary>
/// The BoxCast method is used to generate a boxcast either from the given CustomRaycast object or a default Physics.BoxCast.
/// </summary>
/// <param name="customCast">The optional object with customised cast parameters.</param>
/// <param name="center">The center of the box.</param>
/// <param name="halfExtents">Half the size of the box in each dimension.</param>
/// <param name="direction">The direction in which to cast the box.</param>
/// <param name="orientation">The rotation of the box.</param>
/// <param name="maxDistance">The max length of the cast.</param>
/// <param name="hitData">The boxcast hit data.</param>
/// <param name="ignoreLayers">A layermask of layers to ignore from the boxcast.</param>
/// <param name="affectTriggers">Determines the trigger interaction level of the cast.</param>
/// <returns>Returns true if the boxcast successfully collides with a valid object.</returns>
public static bool BoxCast(VRTK_CustomRaycast customCast, Vector3 center, Vector3 halfExtents, Vector3 direction, Quaternion orientation, float maxDistance, out RaycastHit hitData, LayerMask ignoreLayers, QueryTriggerInteraction affectTriggers = QueryTriggerInteraction.UseGlobal)
{
if (customCast != null)
{
return(customCast.CustomBoxCast(center, halfExtents, direction, orientation, maxDistance, out hitData));
}
else
{
return(Physics.BoxCast(center, halfExtents, direction, out hitData, orientation, maxDistance, ~ignoreLayers, affectTriggers));
}
}
/// <summary>
/// The Linecast method is used to generate a linecast either from the given CustomRaycast object or a default Physics.Linecast.
/// </summary>
/// <param name="customCast">The optional object with customised cast parameters.</param>
/// <param name="startPosition">The world position to start the linecast from.</param>
/// <param name="endPosition">The world position to end the linecast at.</param>
/// <param name="hitData">The linecast hit data.</param>
/// <param name="ignoreLayers">A layermask of layers to ignore from the linecast.</param>
/// <returns>Returns true if the linecast successfully collides with a valid object.</returns>
public static bool Linecast(VRTK_CustomRaycast customCast, Vector3 startPosition, Vector3 endPosition, out RaycastHit hitData, LayerMask ignoreLayers)
{
if (customCast != null)
{
return(customCast.CustomLinecast(startPosition, endPosition, out hitData));
}
else
{
return(Physics.Linecast(startPosition, endPosition, out hitData));
}
}
/// <summary>
/// The Raycast method is used to generate a raycast either from the given CustomRaycast object or a default Physics.Raycast.
/// </summary>
/// <param name="customCast">The optional object with customised cast parameters.</param>
/// <param name="ray">The Ray to cast with.</param>
/// <param name="hitData">The raycast hit data.</param>
/// <param name="ignoreLayers">A layermask of layers to ignore from the raycast.</param>
/// <param name="length">The maximum length of the raycast.</param>
/// <returns>Returns true if the raycast successfully collides with a valid object.</returns>
public static bool Raycast(VRTK_CustomRaycast customCast, Ray ray, out RaycastHit hitData, LayerMask ignoreLayers, float length = Mathf.Infinity)
{
if (customCast != null)
{
return(customCast.CustomRaycast(ray, out hitData, length));
}
else
{
return(Physics.Raycast(ray, out hitData, Mathf.Infinity, ~ignoreLayers));
}
}
protected virtual void AdjustForParentOffset()
{
if (snapToNearestFloor && applyPlayareaParentOffset && playArea != null && playArea.parent != null)
{
Ray ray = new Ray(playArea.parent.position, -playArea.up);
RaycastHit rayCollidedWith;
if (VRTK_CustomRaycast.Raycast(customRaycast, ray, out rayCollidedWith, Physics.IgnoreRaycastLayer, Mathf.Infinity, QueryTriggerInteraction.Ignore))
{
playArea.position = new Vector3(playArea.position.x, playArea.position.y + rayCollidedWith.point.y, playArea.position.z);
}
}
}
protected virtual Vector3 ProjectForwardBeam()
{
Transform origin = GetOrigin();
float attachedRotation = Vector3.Dot(Vector3.up, origin.forward.normalized);
float calculatedLength = maximumLength.x;
Vector3 useForward = origin.forward;
if ((attachedRotation * 100f) > heightLimitAngle)
{
useForward = new Vector3(useForward.x, fixedForwardBeamForward.y, useForward.z);
float controllerRotationOffset = 1f - (attachedRotation - (heightLimitAngle / 100f));
calculatedLength = (maximumLength.x * controllerRotationOffset) * controllerRotationOffset;
}
else
{
fixedForwardBeamForward = origin.forward;
}
float actualLength = calculatedLength;
Ray pointerRaycast = new Ray(origin.position, useForward);
RaycastHit collidedWith;
#pragma warning disable 0618
bool hasRayHit = VRTK_CustomRaycast.Raycast(customRaycast, pointerRaycast, out collidedWith, layersToIgnore, calculatedLength);
#pragma warning restore 0618
float contactDistance = 0f;
//reset if beam not hitting or hitting new target
if (!hasRayHit || (destinationHit.collider && destinationHit.collider != collidedWith.collider))
{
contactDistance = 0f;
}
//check if beam has hit a new target
if (hasRayHit)
{
contactDistance = collidedWith.distance;
}
//adjust beam length if something is blocking it
if (hasRayHit && contactDistance < calculatedLength)
{
actualLength = contactDistance;
}
//Use BEAM_ADJUST_OFFSET to move point back and up a bit to prevent beam clipping at collision point
return(pointerRaycast.GetPoint(actualLength - BEAM_ADJUST_OFFSET) + (Vector3.up * BEAM_ADJUST_OFFSET));
}
protected virtual float GetTeleportY(Transform target, Vector3 tipPosition)
{
float newY = playArea.position.y;
float heightOffset = 0.1f;
//Check to see if the tip is on top of an object
Vector3 rayStartPositionOffset = Vector3.up * heightOffset;
Ray ray = new Ray(tipPosition + rayStartPositionOffset, -playArea.up);
RaycastHit rayCollidedWith;
if (target && VRTK_CustomRaycast.Raycast(customRaycast, ray, out rayCollidedWith, layersToIgnore, Mathf.Infinity))
{
newY = (tipPosition.y - rayCollidedWith.distance) + heightOffset;
}
return(newY);
}
// Token: 0x060018C5 RID: 6341 RVA: 0x000840CC File Offset: 0x000822CC
protected virtual float CastRayForward()
{
Transform origin = base.GetOrigin(true);
Ray ray = new Ray(origin.position, origin.forward);
RaycastHit pointerCollidedWith;
bool flag = VRTK_CustomRaycast.Raycast(this.customRaycast, ray, out pointerCollidedWith, this.layersToIgnore, this.maximumLength, QueryTriggerInteraction.UseGlobal);
this.CheckRayMiss(flag, pointerCollidedWith);
this.CheckRayHit(flag, pointerCollidedWith);
float distance = this.maximumLength;
if (flag && pointerCollidedWith.distance < this.maximumLength)
{
distance = pointerCollidedWith.distance;
}
return(this.OverrideBeamLength(distance));
}
// Token: 0x060017DA RID: 6106 RVA: 0x0007F1DC File Offset: 0x0007D3DC
protected virtual float GetTeleportY(Transform target, Vector3 tipPosition)
{
if (!this.snapToNearestFloor || !this.ValidRigObjects())
{
return(tipPosition.y);
}
float result = this.playArea.position.y;
float num = 0.1f;
Vector3 b = Vector3.up * num;
Ray ray = new Ray(tipPosition + b, -this.playArea.up);
RaycastHit raycastHit;
if (target != null && VRTK_CustomRaycast.Raycast(this.customRaycast, ray, out raycastHit, this.layersToIgnore, float.PositiveInfinity, QueryTriggerInteraction.Ignore))
{
result = tipPosition.y - raycastHit.distance + num;
}
return(result);
}
// Token: 0x06001A4D RID: 6733 RVA: 0x0008B544 File Offset: 0x00089744
protected virtual void RayCastToController(GameObject controller, Transform customDestination, ref bool obscured, ref bool lastState)
{
obscured = false;
if (controller && controller.gameObject.activeInHierarchy)
{
Vector3 endPosition = customDestination ? customDestination.position : controller.transform.position;
RaycastHit hitInfo;
if (VRTK_CustomRaycast.Linecast(this.customRaycast, this.headset.position, endPosition, out hitInfo, default(LayerMask), QueryTriggerInteraction.Ignore))
{
obscured = true;
}
if (lastState != obscured)
{
this.ObscuredStateChanged(controller.gameObject, obscured, hitInfo);
}
lastState = obscured;
}
}
// Token: 0x060018B4 RID: 6324 RVA: 0x000837DC File Offset: 0x000819DC
protected virtual void AdjustForEarlyCollisions(Vector3 jointPosition, Vector3 downPosition)
{
Vector3 vector = downPosition;
Vector3 jointPosition2 = jointPosition;
if (this.collisionCheckFrequency > 0 && this.actualTracer != null)
{
this.collisionCheckFrequency = Mathf.Clamp(this.collisionCheckFrequency, 0, this.tracerDensity);
Vector3[] controlPoints = new Vector3[]
{
base.GetOrigin(true).position,
jointPosition + new Vector3(0f, this.curveOffset, 0f),
downPosition,
downPosition
};
Vector3[] points = this.actualTracer.GetPoints(controlPoints);
int num = this.tracerDensity / this.collisionCheckFrequency;
for (int i = 0; i < this.tracerDensity - num; i += num)
{
Vector3 vector2 = points[i];
Vector3 vector3 = (i + num < points.Length) ? points[i + num] : points[points.Length - 1];
Vector3 normalized = (vector3 - vector2).normalized;
float length = Vector3.Distance(vector2, vector3);
Ray ray = new Ray(vector2, normalized);
RaycastHit raycastHit;
if (VRTK_CustomRaycast.Raycast(this.customRaycast, ray, out raycastHit, this.layersToIgnore, length, QueryTriggerInteraction.UseGlobal))
{
Vector3 point = ray.GetPoint(raycastHit.distance);
Ray ray2 = new Ray(point + Vector3.up * 0.01f, Vector3.down);
RaycastHit destinationHit;
if (VRTK_CustomRaycast.Raycast(this.customRaycast, ray2, out destinationHit, this.layersToIgnore, float.PositiveInfinity, QueryTriggerInteraction.UseGlobal))
{
this.destinationHit = destinationHit;
vector = ray2.GetPoint(destinationHit.distance);
jointPosition2 = ((vector.y < jointPosition.y) ? new Vector3(vector.x, jointPosition.y, vector.z) : jointPosition);
break;
}
}
}
}
this.DisplayCurvedBeam(jointPosition2, vector);
this.SetPointerCursor();
}
protected virtual void RayCastToController(GameObject controller, Transform customDestination, ref bool obscured, ref bool lastState)
{
obscured = false;
if (controller && controller.gameObject.activeInHierarchy)
{
var destination = (customDestination ? customDestination.position : controller.transform.position);
RaycastHit hitInfo;
if (VRTK_CustomRaycast.Linecast(customRaycast, headset.position, destination, out hitInfo, new LayerMask()))
{
obscured = true;
}
if (lastState != obscured)
{
ObscuredStateChanged(controller.gameObject, obscured, hitInfo);
}
lastState = obscured;
}
}
protected virtual void RayCastToController(GameObject controller, Transform customDestination, ref bool obscured, ref bool lastState)
{
obscured = false;
if (controller != null && controller.gameObject.activeInHierarchy)
{
Vector3 destination = (customDestination ? customDestination.position : controller.transform.position);
RaycastHit hitInfo;
if (VRTK_CustomRaycast.Linecast(customRaycast, headset.position, destination, out hitInfo, Physics.IgnoreRaycastLayer, QueryTriggerInteraction.Ignore))
{
obscured = true;
}
if (lastState != obscured)
{
ObscuredStateChanged(controller.gameObject, obscured, hitInfo);
}
lastState = obscured;
}
}
protected virtual float CastRayForward()
{
Transform origin = GetOrigin();
Ray pointerRaycast = new Ray(origin.position, origin.forward);
RaycastHit pointerCollidedWith;
#pragma warning disable 0618
bool rayHit = VRTK_CustomRaycast.Raycast(customRaycast, pointerRaycast, out pointerCollidedWith, layersToIgnore, maximumLength);
#pragma warning restore 0618
CheckRayMiss(rayHit, pointerCollidedWith);
CheckRayHit(rayHit, pointerCollidedWith);
float actualLength = maximumLength;
if (rayHit && pointerCollidedWith.distance < maximumLength)
{
actualLength = pointerCollidedWith.distance;
}
return(OverrideBeamLength(actualLength));
}
protected virtual void SnapToNearestFloor()
{
if (!preventSnapToFloor && (enableBodyCollisions || enableTeleport) && headset && headset.transform.position.y > playArea.position.y)
{
Ray ray = new Ray(headset.transform.position, -playArea.up);
RaycastHit rayCollidedWith;
bool rayHit = VRTK_CustomRaycast.Raycast(customRaycast, ray, out rayCollidedWith, layersToIgnore, Mathf.Infinity);
hitFloorYDelta = playArea.position.y - rayCollidedWith.point.y;
if (initialFloorDrop && (ValidDrop(rayHit, rayCollidedWith, rayCollidedWith.point.y) || retogglePhysicsOnCanFall))
{
storedCurrentPhysics = ArePhysicsEnabled();
resetPhysicsAfterTeleport = false;
TogglePhysics(false);
HandleFall(rayCollidedWith.point.y, rayCollidedWith);
}
initialFloorDrop = true;
lastFrameFloorY = rayCollidedWith.point.y;
}
}
protected virtual void CheckLean()
{
//Cast a ray down from the current standing position
Vector3 standingDownRayStartPosition = (headset != null ? new Vector3(currentStandingPosition.x, headset.position.y, currentStandingPosition.y) : Vector3.zero);
Vector3 rayDirection = (playArea != null ? -playArea.up : Vector3.zero);
Ray standingDownRay = new Ray(standingDownRayStartPosition, rayDirection);
RaycastHit standingDownRayCollision;
//Determine the current valid floor that the user is standing over
#pragma warning disable 0618
currentValidFloorObject = (VRTK_CustomRaycast.Raycast(customRaycast, standingDownRay, out standingDownRayCollision, layersToIgnore, Mathf.Infinity) ? standingDownRayCollision.collider.gameObject : null);
#pragma warning restore 0618
//Don't bother checking for lean if body collisions are disabled
if (headset == null || playArea == null || !enableBodyCollisions)
{
return;
}
//reset the headset x rotation so the forward ray is always horizontal regardless of the headset rotation
Quaternion storedRotation = headset.rotation;
headset.rotation = new Quaternion(0f, headset.rotation.y, headset.rotation.z, headset.rotation.w);
Ray forwardRay = new Ray(headset.position, headset.forward);
RaycastHit forwardRayCollision;
//Determine the maximum forward distance to cast the forward ray
float forwardLength = bodyCollider.radius + leanForwardLengthAddition;
// Cast a ray forward just outside the body collider radius to see if anything is blocking your path
// If nothing is blocking your path and you're currently standing over a valid floor
#pragma warning disable 0618
if (!VRTK_CustomRaycast.Raycast(customRaycast, forwardRay, out forwardRayCollision, layersToIgnore, forwardLength) && currentValidFloorObject != null)
#pragma warning restore 0618
{
CalculateLean(standingDownRayStartPosition, forwardLength, standingDownRayCollision.distance);
}
//put the headset rotation back
headset.rotation = storedRotation;
}
protected virtual float GetTeleportY(Transform target, Vector3 tipPosition)
{
if (!snapToNearestFloor || !ValidRigObjects())
{
return(tipPosition.y);
}
float newY = playArea.position.y;
float heightOffset = 0.1f;
//Check to see if the tip is on top of an object
Vector3 rayStartPositionOffset = Vector3.up * heightOffset;
Ray ray = new Ray(tipPosition + rayStartPositionOffset, -playArea.up);
RaycastHit rayCollidedWith;
#pragma warning disable 0618
if (target != null && VRTK_CustomRaycast.Raycast(customRaycast, ray, out rayCollidedWith, layersToIgnore, Mathf.Infinity, QueryTriggerInteraction.Ignore))
#pragma warning restore 0618
{
newY = (tipPosition.y - rayCollidedWith.distance) + heightOffset;
}
return(newY);
}
// Token: 0x060018B2 RID: 6322 RVA: 0x000835D0 File Offset: 0x000817D0
protected virtual Vector3 ProjectForwardBeam()
{
Transform origin = base.GetOrigin(true);
float num = Vector3.Dot(Vector3.up, origin.forward.normalized);
float num2 = this.maximumLength.x;
Vector3 forward = origin.forward;
if (num * 100f > this.heightLimitAngle)
{
forward = new Vector3(forward.x, this.fixedForwardBeamForward.y, forward.z);
float num3 = 1f - (num - this.heightLimitAngle / 100f);
num2 = this.maximumLength.x * num3 * num3;
}
else
{
this.fixedForwardBeamForward = origin.forward;
}
float num4 = num2;
Ray ray = new Ray(origin.position, forward);
RaycastHit raycastHit;
bool flag = VRTK_CustomRaycast.Raycast(this.customRaycast, ray, out raycastHit, this.layersToIgnore, num2, QueryTriggerInteraction.UseGlobal);
float num5 = 0f;
if (!flag || (this.destinationHit.collider && this.destinationHit.collider != raycastHit.collider))
{
num5 = 0f;
}
if (flag)
{
num5 = raycastHit.distance;
}
if (flag && num5 < num2)
{
num4 = num5;
}
return(ray.GetPoint(num4 - 0.0001f) + Vector3.up * 0.0001f);
}
// Token: 0x060018B3 RID: 6323 RVA: 0x00083714 File Offset: 0x00081914
protected virtual Vector3 ProjectDownBeam(Vector3 jointPosition)
{
Vector3 result = Vector3.zero;
Ray ray = new Ray(jointPosition, Vector3.down);
RaycastHit raycastHit;
bool flag = VRTK_CustomRaycast.Raycast(this.customRaycast, ray, out raycastHit, this.layersToIgnore, this.maximumLength.y, QueryTriggerInteraction.UseGlobal);
if (!flag || (this.destinationHit.collider && this.destinationHit.collider != raycastHit.collider))
{
if (this.destinationHit.collider != null)
{
this.PointerExit(this.destinationHit);
}
this.destinationHit = default(RaycastHit);
result = ray.GetPoint(0f);
}
if (flag)
{
result = ray.GetPoint(raycastHit.distance);
this.PointerEnter(raycastHit);
this.destinationHit = raycastHit;
}
return(result);
}
