Esempio n. 1
0
        private bool UserIsOnNavMesh(StepByStepComponent sbs, TeleportNavMesh tnm, VRRaycastOutputs raycastOutputs, LayerMask excludedLayers, out float3 newCameraRigPos)
        {
            Transform vrCamTransform     = VRSF_Components.VRCamera.transform;
            Transform cameraRigTransform = VRSF_Components.CameraRig.transform;

            // We calculate the direction and the distance Vectors
            var   directionVector = raycastOutputs.RayVar.direction;
            float distanceVector  = cameraRigTransform.localScale.y * sbs.DistanceStepByStep;

            // Check if we hit a collider on the way. If it's the case, we reduce the distance.
            if (Physics.Raycast(vrCamTransform.position, directionVector, out RaycastHit hit, distanceVector, ~excludedLayers))
            {
                distanceVector = hit.distance - 0.1f;
            }

            // We multiply the direction vector by the distance to which the user should be going
            directionVector *= distanceVector;

            // We check the theoritic position for the cameraRig
            newCameraRigPos = GetNewTheoriticPos(directionVector, true);
            // We check the theoritic new user pos
            float3 newCameraPos = GetNewTheoriticPos(directionVector, false);

            // We calculate a vector down based on the new Camera Pos.
            var downVectorDistance = Mathf.Abs(vrCamTransform.localPosition.y + VRSF_Components.FloorOffset.transform.localPosition.y) + sbs.StepHeight;
            var downVector         = newCameraPos + (new float3(0.0f, -1.0f, 0.0f) * downVectorDistance);

            // We calculate the linecast between the newUserPos and the downVector and check if it hits the NavMesh
            TeleportNavMeshHelper.Linecast
            (
                newCameraPos,
                downVector,
                out bool endOnNavmesh,
                excludedLayers,
                out newCameraPos,
                out _,
                tnm
            );

            // We set the camera rig pos in y to the camera pos in y
            newCameraRigPos.y = newCameraPos.y;

            return(endOnNavmesh);


            /// <summary>
            /// We get the theoritic position for the CameraRig and the VRCamera based on the scaled direction (direction * distance)
            /// </summary>
            /// <param name="scaledDirection">The direction multiplied by the distance to go to</param>
            /// <param name="isCheckingCameraRig">Whether the check is for the CameraRig or the VRCamera</param>
            /// <returns>The new Theoritic position</returns>
            float3 GetNewTheoriticPos(Vector3 scaledDirection, bool isCheckingCameraRig)
            {
                float3 origin = isCheckingCameraRig ? cameraRigTransform.position : vrCamTransform.position;

                return(origin + new float3(scaledDirection.x, 0.0f, scaledDirection.z));
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Sample a bunch of points along a parabolic curve until you hit gnd.  At that point, cut off the parabola
        /// </summary>
        ///
        /// <param name="p0">starting point of parabola</param>
        /// <param name="v0">initial parabola velocity</param>
        /// <param name="a">initial acceleration</param>
        /// <param name="dist">distance between sample points</param>
        /// <param name="points">number of sample points</param>
        /// <param name="tnm">Vive Nav Mesh used to teleport</param>
        /// <param name="outPts">List that will be populated by new points</param>
        /// <param name="normal">normal of hit point</param>
        ///
        /// <returns>true if the the parabole is at the end of the NavMesh</returns>
        private static bool CalculateParabolicCurve(float3 p0, Vector3 v0, Vector3 a, float dist, int points, TeleportNavMesh tnm, int excludedLayer, out NativeArray <Translation> outPts, out float3 normal, out int lastPointIndex)
        {
            // Init new list of points with p0 as the first point
            outPts    = new NativeArray <Translation>(points, Allocator.TempJob);
            outPts[0] = new Translation {
                Value = p0
            };

            float3 last = p0;
            float  t    = 0;

            for (int i = 0; i < points; i++)
            {
                t += dist / ParabolicCurveDeriv(v0, a, t).magnitude;
                float3 next = ParabolicCurve(p0, v0, a, t);

                if (TeleportNavMeshHelper.Linecast(last, next, out bool endOnNavmesh, excludedLayer, out float3 castHit, out float3 norm, tnm))
                {
                    outPts[i] = new Translation {
                        Value = castHit
                    };
                    normal         = norm;
                    lastPointIndex = i;
                    return(endOnNavmesh);
                }
Esempio n. 3
0
        /// <summary>
        /// Calculate the points on the way of the Parabola
        /// </summary>
        /// <param name="e">The reference to the entity to check</param>
        /// <param name="velocity">The velocity of the Parabole</param>
        /// <returns>The normal of the Curve</returns>
        public static float3 ParabolaPointsCalculations(ref NativeArray <Translation> pp, ref CurveTeleporterCalculations ctc, ParabolPointsParameters ppp, TeleportNavMesh tnm, float3 parabolOrigin, LayerMask excludedLayer, Vector3 velocity)
        {
            ctc.PointOnNavMesh = CalculateParabolicCurve
                                 (
                parabolOrigin,
                velocity,
                ctc.Acceleration,
                ppp.PointSpacing,
                ppp.PointCount,
                tnm,
                excludedLayer,
                out pp,
                out float3 normal,
                out ctc.LastPointIndex
                                 );

            ctc.PointToGoTo = pp[ctc.LastPointIndex].Value;
            return(normal);
        }
        /// <summary>
        /// Casts a ray against the Navmesh and attempts to calculate the ray's worldspace intersection with it.
        /// This uses Physics raycasts to perform the raycast calculation, so the teleport surface must have a collider on it.
        /// </summary>
        ///
        /// <param name="p1">First (origin) point of ray</param>
        /// <param name="p2">Last (end) point of ray</param>
        /// <param name="pointOnNavmesh">If the raycast hit something on the navmesh</param>
        /// <param name="hitPoint">If hit, the point of the hit. Otherwise zero.</param>
        /// <param name="normal">If hit, the normal of the hit surface.  Otherwise (0, 1, 0)</param>
        ///
        /// <returns>If the raycast hit something.</returns>
        public static bool Linecast(float3 p1, float3 p2, out bool pointOnNavmesh, int excludedLayer, out float3 hitPoint, out float3 normal, TeleportNavMesh tnm)
        {
            Vector3 dir  = p2 - p1;
            float   dist = dir.magnitude;

            dir /= dist;

            if (Physics.Raycast(p1, dir, out RaycastHit hit, dist, ~excludedLayer, (QueryTriggerInteraction)tnm.QueryTriggerInteraction))
            {
                normal   = hit.normal;
                hitPoint = hit.point;

                if (tnm.IgnoreSlopedSurfaces && math.dot(Vector3.up, hit.normal) < 0.99f)
                {
                    pointOnNavmesh = false;
                    return(true);
                }

                pointOnNavmesh = NavMesh.SamplePosition(hitPoint, out NavMeshHit navHit, tnm.SampleRadius, tnm.NavAreaMask);
                // Get the closest position on the navMesh
                if (Vector3IsCorrect(navHit.position))
                {
                    hitPoint = navHit.position;
                }
                return(true);
            }