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に当たってれば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); }