internal static void DrawPathGizmo(CinemachinePathBase path, Color pathColor)
        {
            // Draw the path
            var colorOld = Gizmos.color;

            Gizmos.color = pathColor;
            var step    = 1f / path.m_Resolution;
            var lastPos = path.EvaluatePosition(path.MinPos);
            var lastW   = path.EvaluateOrientation(path.MinPos)
                          * Vector3.right * path.m_Appearance.width / 2;

            for (var t = path.MinPos + step; t <= path.MaxPos + step / 2; t += step)
            {
                var p  = path.EvaluatePosition(t);
                var q  = path.EvaluateOrientation(t);
                var w  = q * Vector3.right * path.m_Appearance.width / 2;
                var w2 = w * 1.2f;
                var p0 = p - w2;
                var p1 = p + w2;
                Gizmos.DrawLine(p0, p1);
                Gizmos.DrawLine(lastPos - lastW, p - w);
                Gizmos.DrawLine(lastPos + lastW, p + w);
#if false
// Show the normals, for debugging
                Gizmos.color = Color.red;
                Vector3 y = (q * Vector3.up) * width / 2;
                Gizmos.DrawLine(p, p + y);
                Gizmos.color = pathColor;
#endif
                lastPos = p;
                lastW   = w;
            }

            Gizmos.color = colorOld;
        }
示例#2
0
        public static void DrawPathGizmo(CinemachinePathBase path, Color pathColor)
        {
            // Draw the path
            Color colorOld = Gizmos.color;

            Gizmos.color = pathColor;
            float   step    = 1f / path.m_Resolution;
            Vector3 lastPos = path.EvaluatePosition(path.MinPos);
            Vector3 lastW   = (path.EvaluateOrientation(path.MinPos)
                               * Vector3.right) * path.m_Appearance.width / 2;

            for (float t = path.MinPos + step; t <= path.MaxPos + step / 2; t += step)
            {
                Vector3    p  = path.EvaluatePosition(t);
                Quaternion q  = path.EvaluateOrientation(t);
                Vector3    w  = (q * Vector3.right) * path.m_Appearance.width / 2;
                Vector3    w2 = w * 1.2f;
                Vector3    p0 = p - w2;
                Vector3    p1 = p + w2;
                Gizmos.DrawLine(p0, p1);
                Gizmos.DrawLine(lastPos - lastW, p - w);
                Gizmos.DrawLine(lastPos + lastW, p + w);
#if false
                // Show the normals, for debugging
                Gizmos.color = Color.red;
                Vector3 y = (q * Vector3.up) * path.m_Appearance.width / 2;
                Gizmos.DrawLine(p, p + y);
                Gizmos.color = pathColor;
#endif
                lastPos = p;
                lastW   = w;
            }
            Gizmos.color = colorOld;
        }
示例#3
0
            public PathMeshNode(CinemachinePathBase path, float time)
            {
                Vector3    center      = path.EvaluatePosition(time);
                Quaternion orientation = path.EvaluateOrientation(time);

                Normal = orientation * Vector3.up;

                float   halfWidth    = path.m_Appearance.width / 2f;
                Vector3 originOffset = path.transform.position;

                RightPosition  = center + orientation * Vector3.right * halfWidth;
                RightPosition -= originOffset;

                LeftPosition  = center + orientation * Vector3.left * halfWidth;
                LeftPosition -= originOffset;
            }
示例#4
0
        public static int GetClosestPoint(this CinemachinePathBase path, Vector3 samplePosition)
        {
            float closestDistSqr = Mathf.Infinity;
            int   closestPos     = -1;

            for (int pos = (int)path.MinPos; pos < path.MaxPos; ++pos)
            {
                Vector3 worldPos = path.EvaluatePosition(pos);
                float   distSqr  = (worldPos - samplePosition).sqrMagnitude;

                if (distSqr < closestDistSqr)
                {
                    closestDistSqr = distSqr;
                    closestPos     = pos;
                }
            }

            return(closestPos);
        }
示例#5
0
        public static void PopulateLineRenderPoints(this CinemachinePathBase path, LineRenderer renderer)
        {
            float maxStepLength = 1f / path.m_Resolution;
            int   maxPoints     = Mathf.CeilToInt(path.MaxPos / maxStepLength) + 1;

            Vector3[] worldPoints = new Vector3[maxPoints];

            int idx = 0;

            for (float tdx = 0; tdx < path.MaxPos; tdx += maxStepLength)
            {
                Vector3 worldPos = path.EvaluatePosition(tdx);
                worldPoints[idx++] = worldPos;
            }

            renderer.positionCount = maxPoints;
            renderer.SetPositions(worldPoints);

            renderer.useWorldSpace = true;
            renderer.loop          = path.Looped;
        }
示例#6
0
        // Fixed update is called in sync with physics
        private void FixedUpdate()
        {
            Profiler.BeginSample("Character Controller Pathing");
            int startPos = Mathf.FloorToInt(currentPathPosition) - 1;

            if (startPos < 0)
            {
                startPos = 0;
            }
            currentPathPosition = path.FindClosestPoint(transform.position, startPos, 3, 5);
            Vector3 closestPoint = path.EvaluatePosition(currentPathPosition);
            Vector3 tangent      = path.EvaluateTangent(currentPathPosition);

            tangent.y = 0;
            tangent.Normalize();

            Vector3 targetDir = tangent;

            // read inputs
            float h = CrossPlatformInputManager.GetAxis("Horizontal");
            float v = CrossPlatformInputManager.GetAxis("Vertical");

            h = adjustedInput.Evaluate(Mathf.Abs(h)) * Mathf.Sign(h);
            v = adjustedInput.Evaluate(Mathf.Abs(v)) * Mathf.Sign(v);

            // Correction when too far away from path
            closestPoint.y = 0;
            Vector3 pos = transform.position;

            pos.y = 0;
            Vector3 dirToPath = (closestPoint - pos);

            dirToPath.y = 0;
            float pathDist = dirToPath.magnitude;

            pathDist -= pathDistanceTolerance;
            dirToPath.Normalize();
            Debug.DrawLine(closestPoint, closestPoint + tangent * 3);

            if (pathDist > 0)
            {
                if (h < 0)
                {
                    dirToPath = -dirToPath;
                }
                targetDir = Vector3.Lerp(tangent, dirToPath, pathDist * pathDistanceSteering);
            }

            Profiler.EndSample();


            m_Move = targetDir * h;
            bool crouch = Input.GetKey(KeyCode.C);

//            // calculate move direction to pass to character
//            if (m_Cam != null)
//            {
//                // calculate camera relative direction to move:
//                m_CamForward = Vector3.Scale(m_Cam.forward, new Vector3(1, 0, 1)).normalized;
//                m_Move = v * m_CamForward + h * m_Cam.right;
//            }
//            else
//            {
//                // we use world-relative directions in the case of no main camera
//                m_Move = v * Vector3.forward + h * Vector3.right;
//            }
#if !MOBILE_INPUT
            // walk speed multiplier
            if (Input.GetKey(KeyCode.LeftShift))
            {
                m_Move *= 0.5f;
            }
#endif


            // add vertical input
            m_Move.y = v;

            // pass all parameters to the character control script
            m_Character.Move(m_Move, crouch, m_Jump);
            m_Jump = false;
        }