Esempio n. 1
0
 public Part(PartT _t, int _a, int _b, int _c, int _d)
 {
     t = _t;
     a = _a;
     b = _b;
     c = _c;
     d = _d;
 }
Esempio n. 2
0
        public static IEnumerable <PartT> CalculateDashesBezierT(BezierTrajectory bezierTrajectory, float dashLength, float spaceLength, uint iterations = 3)
        {
            var points  = GetDashesBezierPoints(bezierTrajectory);
            var indices = CalculateDashesBezierT(points, dashLength, spaceLength, iterations);
            var count   = points.Length - 1;

            for (var j = 1; j < indices.Count; j += 2)
            {
                var part = new PartT {
                    Start = 1f / count * indices[j - 1], End = 1f / count * indices[j]
                };
                yield return(part);
            }
        }
Esempio n. 3
0
    public void add_part(PartT i, int a, int b = -1, int c = -1, int d = -1)
    {
        switch (i)
        {
        case PartT.Plain:
            if (a < 0 || a >= literals.Count || c >= literals.Count)
            {
                return;
            }
            if (c != -1 && d > literals[c].Length)
            {
                return;
            }
            if (b < 1)
            {
                b = 1;
            }
            break;

        case PartT.RandomN:
            if (a > b)
            {
                return;
            }
            ++b;                     // since Random.Next is [) and we want [a,b] as int
            break;

        case PartT.RandomPool:
            if (a < 0 || a >= literals.Count || c >= literals.Count)
            {
                return;
            }
            if (d == -1)
            {
                d = 1;
            }
            if (b == -1)
            {
                b = 1;
            }
            break;

        case PartT.SubStr:
            if (a < 0 || b < 0 || b >= c || a >= literals.Count || c > (literals[a].Length))
            {
                return;
            }
            break;

        case PartT.Clone:
            if (a < 0 || a >= parts.Count)
            {
                return;
            }
            i = parts[a].t;
            b = parts[a].b;
            c = parts[a].c;
            d = parts[a].d;
            a = parts[a].a;
            break;

        /*
         * case PartT.NSeries:
         *      if (c==0) return; // we'll never reach b
         *      if (c<0 && b>a) return; // we'll never reach b
         *      if (c>0 && a>b) return; // we'll never reach b
         *      if (d==-1) d = a;
         *      if (d>b || d<a) return; // d isn't in range
         *      break;
         */
        default:
            return;
        }
        parts.Add(new Part(i, a, b, c, d));
    }