예제 #1
0
 /// <summary>
 /// Makes sure every control point follows the rules of the knot they belong to, or re-auto generates the control
 /// points.
 /// </summary>
 public void RecalculateControlPoints()
 {
     _path = null;
     if (AutoControlPoints)
     {
         IEnumerable <Vector3> points = _knots.Select(knot => knot.Position);
         var newKnots = CubicBezierKnotUtils.GeneratePathKnots(Looped, points, Tension, Bias, Continuity, true);
         // Copy up positions over to knew knots.
         for (int i = 0; i < _knots.Count; ++i)
         {
             newKnots[i].Up = _knots[i].Up;
         }
         _knots = newKnots;
     }
     else
     {
         for (int i = 0; i < _knots.Count; ++i)
         {
             _knots[i].RecalculateControlPoint(true, true);
         }
     }
 }
예제 #2
0
        /// <summary>
        /// Creates an automatic bezier path between the given list of points. If tension, bias and continuity are all 0,
        /// This path will be a catmull-rom spline.
        /// </summary>
        /// <param name="tension">
        /// A tension of 0 indicates smooth corners. A tension of 1 indicates sharp corners. Values larger than
        /// this range can cause the curves to overshoot. Values smaller than 0 will cause the curves to fold into
        /// themselves.
        /// </param>
        /// <summary>
        /// Bias affects how automatic control points should be generated. For a given knot, a positive bias means there
        /// will be a strong bend at the start of the outgoing segment, and a negative bias means there will be a strong
        /// bend at the end of the incomming segment. The default bias of 0 gives a neutral weighting.
        /// </summary>
        /// <summary>
        /// Continuity affects how automatic control points should be generated. If this value is 0, control points will
        /// be C1 continious, (no instant changes in velocity, unless tension is >= 1). This can be though to change how
        /// sharp the shape is.
        /// </summary>
        /// <param name="looped">
        /// Whether the path should be looped or not.
        /// </param>
        /// <param name="overshootMode">
        /// How path overshooting should be handled.
        /// </param>
        /// <param name="points">The points the bezier should map through.</param>
        public AutoBezierPath(float tension, float bias, float continuity, bool looped, PathOvershootMode overshootMode,
                              IEnumerable <Vector3> points)
        {
            List <CubicBezierKnot> knots = CubicBezierKnotUtils.GeneratePathKnots(looped, points, tension, bias, continuity);
            var paths = new List <IPath>();

            int numberOfPoints = points.Count();
            int count          = looped ? numberOfPoints : numberOfPoints - 1;

            for (int i = 0; i < count; ++i)
            {
                int             index     = i;
                int             nextIndex = (i + 1) % numberOfPoints;
                CubicBezierKnot firstKnot = knots[index];
                CubicBezierKnot nextKnot  = knots[nextIndex];

                var path = new NormalizedBezierPath(firstKnot.Position, firstKnot.OutControlPoint, nextKnot.InControlPoint,
                                                    nextKnot.Position);
                paths.Add(path);
            }
            _path = new ChainedPath(overshootMode, paths);
        }