@wcardinal/wcardinal-ui 0.408.0 → 0.410.0

package/dist/wcardinal/ui/shape/variant/build-line.js

@@ -1,9 +1,13 @@
-import { Point } from "pixi.js";
 import { toDash } from "./to-dash";
-import { toLength } from "./to-length";
 import { toScaleInvariant } from "./to-scale-invariant";
+import { toNormalPacked } from "./to-normal-packed";
+import { toVectorLength } from "./to-vector-length";
+import { toVector } from "./to-vector";
+import { toNormal } from "./to-normal";
+import { toPackedI4x64 } from "./to-packed";
 var LINE_FMIN = 0.00001;
-var LINE_WORK_POINT = new Point();
+var LINE_NPREV = [0, 1];
+var LINE_NNEXT = [0, 1];
 export var toPointCount = function (points) {
     if (points) {
         return points.formatted.plength;
@@ -25,32 +29,6 @@ export var toLineVertexCount = function (pointCount, isClosed) {
 export var toLineIndexCount = function (pointCount, isClosed) {
     return toLineVertexCount(pointCount, isClosed) - 2;
 };
-export var buildLineClipping = function (clippings, voffset, vcount, pointCount) {
-    var ic = voffset * 3 - 1;
-    var icmax = (voffset + vcount) * 3 - 1;
-    for (var i = 0; i < pointCount; ++i) {
-        clippings[++ic] = 1;
-        clippings[++ic] = 0;
-        clippings[++ic] = 3;
-        clippings[++ic] = 0;
-        clippings[++ic] = 1;
-        clippings[++ic] = 5;
-        clippings[++ic] = 1;
-        clippings[++ic] = 0;
-        clippings[++ic] = 4;
-        clippings[++ic] = 0;
-        clippings[++ic] = 1;
-        clippings[++ic] = 6;
-    }
-    for (; ic < icmax;) {
-        clippings[++ic] = 1;
-        clippings[++ic] = 0;
-        clippings[++ic] = 3;
-        clippings[++ic] = 0;
-        clippings[++ic] = 1;
-        clippings[++ic] = 5;
-    }
-};
 export var buildLineIndex = function (indices, voffset, ioffset, icount) {
     var ii = ioffset * 3 - 1;
     var iimax = (ioffset + icount) * 3 - 1;
@@ -65,7 +43,7 @@ export var buildLineIndex = function (indices, voffset, ioffset, icount) {
         io += 2;
     }
 };
-export var buildLineUv = function (uvs, colorFills, voffset, vcount, textureUvs, length) {
+export var buildLineUv = function (uvs, steps, voffset, vcount, textureUvs, length) {
     var lengthInverse = 1 / Math.max(LINE_FMIN, length);
     var x0 = textureUvs.x0;
     var x1 = textureUvs.x1;
@@ -81,9 +59,9 @@ export var buildLineUv = function (uvs, colorFills, voffset, vcount, textureUvs,
     var dy32 = y2 - y3;
     var iuv = (voffset << 1) - 1;
     var iuvmax = ((voffset + vcount) << 1) - 1;
-    var icf = (voffset << 2) - 8;
+    var is = voffset * 6 - 9;
     for (; iuv < iuvmax;) {
-        var r = colorFills[(icf += 8)] * lengthInverse;
+        var r = steps[(is += 12)] * lengthInverse;
         uvs[++iuv] = x0 + r * dx01;
         uvs[++iuv] = y0 + r * dy01;
         uvs[++iuv] = x3 + r * dx32;
@@ -91,7 +69,7 @@ export var buildLineUv = function (uvs, colorFills, voffset, vcount, textureUvs,
     }
 };
 var TRANSFORMED_POINT_VALUES;
-export var buildLineVertexStepAndColorFill = function (vertices, steps, colorFills, voffset, vcount, pointCount, pointsClosed, pointValues, pointSegments, strokeWidth, strokeStyle, internalTransform) {
+export var buildLineVertexStep = function (vertices, steps, voffset, vcount, pointCount, pointsClosed, pointValues, pointSegments, strokeWidth, strokeStyle, internalTransform) {
     var transformedPointValues = TRANSFORMED_POINT_VALUES;
     if (transformedPointValues == null) {
         transformedPointValues = [];
@@ -110,29 +88,29 @@ export var buildLineVertexStepAndColorFill = function (vertices, steps, colorFil
         transformedPointValues[iv] = a * x + c * y + tx;
         transformedPointValues[iv + 1] = b * x + d * y + ty;
     }
-    return buildTransformedLineVertexStepAndColorFill(vertices, steps, colorFills, voffset, vcount, pointCount, pointsClosed, transformedPointValues, pointSegments, strokeWidth, strokeStyle);
+    return buildTransformedLineVertexStep(vertices, steps, voffset, vcount, pointCount, pointsClosed, transformedPointValues, pointSegments, strokeWidth, strokeStyle);
 };
-var fillTransformedLineVertexStepAndColorFill = function (iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, llo) {
+var fillTransformedLineVertexStep = function (iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, llo, e0, e1) {
+    var d = toNormalPacked(nprev, nnext);
+    var l = Math.min(lprev, lnext);
     vertices[++iv] = px;
     vertices[++iv] = py;
     steps[++is] = strokeWidth;
-    steps[++is] = scaleInvariant;
-    steps[++is] = pprevx;
-    steps[++is] = pprevy;
-    steps[++is] = pnextx;
-    steps[++is] = pnexty;
-    colorFills[(icf += 1)] = llo;
+    steps[++is] = e0;
+    steps[++is] = d;
+    steps[++is] = llo;
+    steps[++is] = llo;
+    steps[++is] = l;
     vertices[++iv] = px;
     vertices[++iv] = py;
     steps[++is] = strokeWidth;
-    steps[++is] = scaleInvariant;
-    steps[++is] = pprevx;
-    steps[++is] = pprevy;
-    steps[++is] = pnextx;
-    steps[++is] = pnexty;
-    colorFills[(icf += 4)] = llo;
+    steps[++is] = e1;
+    steps[++is] = d;
+    steps[++is] = llo;
+    steps[++is] = llo;
+    steps[++is] = l;
 };
-var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colorFills, voffset, vcount, lineVertexCount, lineIsClosed, lineVertices, lineSegments, strokeWidth, strokeStyle) {
+var buildTransformedLineVertexStep = function (vertices, steps, voffset, vcount, lineVertexCount, lineIsClosed, lineVertices, lineSegments, strokeWidth, strokeStyle) {
     var lineSegmentsLength = lineSegments.length;
     if (0 < lineSegmentsLength) {
         if (lineIsClosed) {
@@ -144,7 +122,7 @@ var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colo
             for (var i = 1; i < lineSegmentsLength; ++i) {
                 iseg = lineSegments[i];
                 if (2 <= iseg - iprevseg) {
-                    lprev = buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, -1, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                    lprev = buildTransformedLineOpenSegmentVertexStep(vertices, steps, ivoffset, -1, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
                     lmax = Math.max(lmax, lprev);
                     ivoffset += toLineVertexCount(iseg - iprevseg, false);
                 }
@@ -153,12 +131,12 @@ var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colo
             // Last
             iseg = lineSegments[0] + lineVertexCount;
             if (2 <= iseg - iprevseg) {
-                lprev = buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                lprev = buildTransformedLineOpenSegmentVertexStep(vertices, steps, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
                 lmax = Math.max(lmax, lprev);
                 ivoffset += toLineVertexCount(iseg - iprevseg, false);
             }
             else {
-                buildTransformedLineEmptyVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                buildTransformedLineEmptyVertexStep(vertices, steps, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
             }
             return lmax;
         }
@@ -169,7 +147,7 @@ var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colo
             // First
             var iseg = lineSegments[0];
             if (2 <= iseg) {
-                lprev = buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, -1, lineVertices, 0, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                lprev = buildTransformedLineOpenSegmentVertexStep(vertices, steps, ivoffset, -1, lineVertices, 0, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
                 lmax = Math.max(lmax, lprev);
                 ivoffset += toLineVertexCount(iseg, false);
             }
@@ -178,7 +156,7 @@ var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colo
             for (var i = 1; i < lineSegmentsLength; ++i) {
                 iseg = lineSegments[i];
                 if (2 <= iseg - iprevseg) {
-                    lprev = buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, -1, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                    lprev = buildTransformedLineOpenSegmentVertexStep(vertices, steps, ivoffset, -1, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
                     lmax = Math.max(lmax, lprev);
                     ivoffset += toLineVertexCount(iseg - iprevseg, false);
                 }
@@ -187,31 +165,33 @@ var buildTransformedLineVertexStepAndColorFill = function (vertices, steps, colo
             // Last
             iseg = lineVertexCount;
             if (2 <= iseg - iprevseg) {
-                lprev = buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                lprev = buildTransformedLineOpenSegmentVertexStep(vertices, steps, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
                 lmax = Math.max(lmax, lprev);
                 ivoffset += toLineVertexCount(iseg - iprevseg, false);
             }
             else {
-                buildTransformedLineEmptyVertexStepAndColorFill(vertices, steps, colorFills, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
+                buildTransformedLineEmptyVertexStep(vertices, steps, ivoffset, voffset + vcount - ivoffset, lineVertices, iprevseg, iseg, lineVertexCount, strokeWidth, strokeStyle, lprev);
             }
             return lmax;
         }
     }
     else {
         if (lineIsClosed) {
-            return buildTransformedLineClosedSegmentVertexStepAndColorFill(vertices, steps, colorFills, voffset, vcount, lineVertices, 0, lineVertexCount, lineVertexCount, strokeWidth, strokeStyle);
+            return buildTransformedLineClosedSegmentVertexStep(vertices, steps, voffset, vcount, lineVertices, 0, lineVertexCount, lineVertexCount, strokeWidth, strokeStyle);
         }
         else {
-            return buildTransformedLineOpenSegmentVertexStepAndColorFill(vertices, steps, colorFills, voffset, vcount, lineVertices, 0, lineVertexCount, lineVertexCount, strokeWidth, strokeStyle, 0);
+            return buildTransformedLineOpenSegmentVertexStep(vertices, steps, voffset, vcount, lineVertices, 0, lineVertexCount, lineVertexCount, strokeWidth, strokeStyle, 0);
         }
     }
 };
-var buildTransformedLineEmptyVertexStepAndColorFill = function (vertices, steps, colorFills, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle, length) {
+var buildTransformedLineEmptyVertexStep = function (vertices, steps, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle, length) {
     if (0 <= vcount) {
         var scaleInvariant = toScaleInvariant(strokeStyle);
+        var dash = toDash(strokeStyle);
+        var e3 = toPackedI4x64(3, scaleInvariant, dash, 0);
+        var e5 = toPackedI4x64(5, scaleInvariant, dash, 0);
         var iv = (voffset << 1) - 1;
         var is = voffset * 6 - 1;
-        var icf = (voffset << 2) - 1;
         var ivmax = ((voffset + vcount) << 1) - 1;
         var ifirst = lineVertexFrom % lineVertexCount << 1;
         var px = lineVertices[ifirst];
@@ -220,21 +200,30 @@ var buildTransformedLineEmptyVertexStepAndColorFill = function (vertices, steps,
             vertices[++iv] = px;
             vertices[++iv] = py;
             steps[++is] = 0;
-            steps[++is] = scaleInvariant;
-            steps[++is] = -1;
+            steps[++is] = e3;
+            steps[++is] = 0;
+            steps[++is] = length;
+            steps[++is] = length;
+            steps[++is] = 0;
+            vertices[++iv] = px;
+            vertices[++iv] = py;
+            steps[++is] = 0;
+            steps[++is] = e5;
             steps[++is] = 0;
-            steps[++is] = +1;
+            steps[++is] = length;
+            steps[++is] = length;
             steps[++is] = 0;
-            colorFills[++icf] = length;
-            colorFills[++icf] = 0;
-            colorFills[++icf] = 0;
-            colorFills[++icf] = length;
         }
     }
     return 0;
 };
-var buildTransformedLineOpenSegmentVertexStepAndColorFill = function (vertices, steps, colorFills, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle, length) {
+var buildTransformedLineOpenSegmentVertexStep = function (vertices, steps, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle, length) {
     var scaleInvariant = toScaleInvariant(strokeStyle);
+    var dash = toDash(strokeStyle);
+    var e3 = toPackedI4x64(3, scaleInvariant, dash, 0);
+    var e4 = toPackedI4x64(4, scaleInvariant, dash, 0);
+    var e5 = toPackedI4x64(5, scaleInvariant, dash, 0);
+    var e6 = toPackedI4x64(6, scaleInvariant, dash, 0);
     // First segment
     var ifirst = lineVertexFrom % lineVertexCount << 1;
     var px = lineVertices[ifirst];
@@ -244,90 +233,105 @@ var buildTransformedLineOpenSegmentVertexStepAndColorFill = function (vertices,
     var pnexty = lineVertices[isecond + 1];
     var pprevx = px - (pnextx - px);
     var pprevy = py - (pnexty - py);
+    var nprev = LINE_NPREV;
+    var nnext = LINE_NNEXT;
+    toVector(pprevx, pprevy, px, py, nprev);
+    toVector(px, py, pnextx, pnexty, nnext);
+    var lprev = toVectorLength(nprev);
+    var lnext = lprev;
+    toNormal(nprev, lprev);
+    toNormal(nnext, lnext);
     var iv = (voffset << 1) - 1;
     var is = voffset * 6 - 1;
-    var icf = (voffset << 2) - 1;
     var l = 0;
-    fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, length);
+    fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, length, e3, e5);
     iv += 4;
     is += 12;
-    icf += 8;
-    fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+    fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e4, e6);
     iv += 4;
     is += 12;
-    icf += 8;
     // Middle segments
     for (var i = lineVertexFrom + 1, imax = lineVertexTo - 1; i < imax; ++i) {
         pprevx = px;
         pprevy = py;
         px = pnextx;
         py = pnexty;
+        nprev[0] = nnext[0];
+        nprev[1] = nnext[1];
+        lprev = lnext;
         var imiddle = (i + 1) % lineVertexCount << 1;
         pnextx = lineVertices[imiddle];
         pnexty = lineVertices[imiddle + 1];
-        l += toLength(pprevx, pprevy, px, py);
-        fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+        toVector(px, py, pnextx, pnexty, nnext);
+        lnext = toVectorLength(nnext);
+        toNormal(nnext, lnext);
+        l += lprev;
+        fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e3, e5);
         iv += 4;
         is += 12;
-        icf += 8;
-        fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+        fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e4, e6);
         iv += 4;
         is += 12;
-        icf += 8;
     }
     // Last segment
     pprevx = px;
     pprevy = py;
     px = pnextx;
     py = pnexty;
+    nprev[0] = nnext[0];
+    nprev[1] = nnext[1];
+    lprev = lnext;
     pnextx = px + (px - pprevx);
     pnexty = py + (py - pprevy);
-    l += toLength(pprevx, pprevy, px, py);
-    fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+    toVector(px, py, pnextx, pnexty, nnext);
+    toNormal(nnext, lnext);
+    l += lprev;
+    fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e3, e5);
     iv += 4;
     is += 12;
-    icf += 8;
-    fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+    fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e4, e6);
     iv += 4;
     is += 12;
-    icf += 8;
     // Total length
-    var dash = toDash(l, strokeWidth, strokeStyle, LINE_WORK_POINT);
-    var dash0 = dash.x;
-    var dash1 = dash.y;
-    var icf0 = (voffset << 2) - 1;
-    for (var i = icf0, imax = icf0 + 8; i < imax; i += 4) {
-        colorFills[i + 2] = dash0;
-        colorFills[i + 3] = dash1;
-        colorFills[i + 4] = length;
+    var is0 = voffset * 6 - 1;
+    for (var i = is0, imax = is0 + 12; i < imax; i += 6) {
+        steps[i + 5] = length;
     }
-    for (var i = icf0 + 8; i < icf; i += 4) {
-        colorFills[i + 2] = dash0;
-        colorFills[i + 3] = dash1;
-        colorFills[i + 4] = l;
+    for (var i = is0 + 12; i < is; i += 6) {
+        steps[i + 5] = l;
     }
     // Fill the rest
     if (0 <= vcount) {
+        var d = toNormalPacked(nprev, nnext);
         var ivmax = ((voffset + vcount) << 1) - 1;
         for (; iv < ivmax;) {
             vertices[++iv] = px;
             vertices[++iv] = py;
             steps[++is] = 0;
-            steps[++is] = scaleInvariant;
-            steps[++is] = pprevx;
-            steps[++is] = pprevy;
-            steps[++is] = pnextx;
-            steps[++is] = pnexty;
-            colorFills[++icf] = l;
-            colorFills[++icf] = dash0;
-            colorFills[++icf] = dash1;
-            colorFills[++icf] = l;
+            steps[++is] = e3;
+            steps[++is] = d;
+            steps[++is] = l;
+            steps[++is] = l;
+            steps[++is] = 0;
+            vertices[++iv] = px;
+            vertices[++iv] = py;
+            steps[++is] = 0;
+            steps[++is] = e5;
+            steps[++is] = d;
+            steps[++is] = l;
+            steps[++is] = l;
+            steps[++is] = 0;
         }
     }
     return l;
 };
-var buildTransformedLineClosedSegmentVertexStepAndColorFill = function (vertices, steps, colorFills, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle) {
+var buildTransformedLineClosedSegmentVertexStep = function (vertices, steps, voffset, vcount, lineVertices, lineVertexFrom, lineVertexTo, lineVertexCount, strokeWidth, strokeStyle) {
     var scaleInvariant = toScaleInvariant(strokeStyle);
+    var dash = toDash(strokeStyle);
+    var e3 = toPackedI4x64(3, scaleInvariant, dash, 0);
+    var e4 = toPackedI4x64(4, scaleInvariant, dash, 0);
+    var e5 = toPackedI4x64(5, scaleInvariant, dash, 0);
+    var e6 = toPackedI4x64(6, scaleInvariant, dash, 0);
     var ilast = (lineVertexTo - 1) % lineVertexCount << 1;
     var pprevx = 0;
     var pprevy = 0;
@@ -336,66 +340,82 @@ var buildTransformedLineClosedSegmentVertexStepAndColorFill = function (vertices
     var ifirst = lineVertexFrom % lineVertexCount << 1;
     var pnextx = lineVertices[ifirst];
     var pnexty = lineVertices[ifirst + 1];
+    var nprev = LINE_NPREV;
+    var nnext = LINE_NNEXT;
+    toVector(pprevx, pprevy, px, py, nprev);
+    toVector(px, py, pnextx, pnexty, nnext);
+    var lprev = toVectorLength(nprev);
+    var lnext = toVectorLength(nnext);
+    toNormal(nprev, lprev);
+    toNormal(nnext, lnext);
     var l = 0;
     var iv = (voffset << 1) - 1;
     var is = voffset * 6 - 1;
-    var icf = (voffset << 2) - 1;
     for (var i = lineVertexFrom; i < lineVertexTo; ++i) {
         pprevx = px;
         pprevy = py;
         px = pnextx;
         py = pnexty;
+        nprev[0] = nnext[0];
+        nprev[1] = nnext[1];
+        lprev = lnext;
         var imiddle = (i + 1) % lineVertexCount << 1;
         pnextx = lineVertices[imiddle];
         pnexty = lineVertices[imiddle + 1];
-        l += toLength(pprevx, pprevy, px, py);
-        fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+        toVector(px, py, pnextx, pnexty, nnext);
+        lnext = toVectorLength(nnext);
+        toNormal(nnext, lnext);
+        l += lprev;
+        fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e3, e5);
         iv += 4;
         is += 12;
-        icf += 8;
-        fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+        fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e4, e6);
         iv += 4;
         is += 12;
-        icf += 8;
     }
     // Last segment
     pprevx = px;
     pprevy = py;
     px = pnextx;
     py = pnexty;
+    nprev[0] = nnext[0];
+    nprev[1] = nnext[1];
+    lprev = lnext;
     var isecond = (lineVertexFrom + 1) % lineVertexCount << 1;
     pnextx = lineVertices[isecond];
     pnexty = lineVertices[isecond + 1];
-    l += toLength(pprevx, pprevy, px, py);
-    fillTransformedLineVertexStepAndColorFill(iv, vertices, is, steps, icf, colorFills, px, py, strokeWidth, scaleInvariant, pprevx, pprevy, pnextx, pnexty, l);
+    toVector(px, py, pnextx, pnexty, nnext);
+    lnext = toVectorLength(nnext);
+    toNormal(nnext, lnext);
+    l += lprev;
+    fillTransformedLineVertexStep(iv, vertices, is, steps, px, py, strokeWidth, nprev, nnext, lprev, lnext, l, e3, e5);
     iv += 4;
     is += 12;
-    icf += 8;
     // Total length
-    var dash = toDash(l, strokeWidth, strokeStyle, LINE_WORK_POINT);
-    var dash0 = dash.x;
-    var dash1 = dash.y;
-    for (var i = (voffset << 2) - 1; i < icf; i += 4) {
-        colorFills[i + 2] = dash0;
-        colorFills[i + 3] = dash1;
-        colorFills[i + 4] = -1;
+    for (var i = voffset * 6 - 1; i < is; i += 6) {
+        steps[i + 5] = -l;
     }
     // Fill the rest
     if (0 <= vcount) {
+        var d = toNormalPacked(nprev, nnext);
         var ivmax = ((voffset + vcount) << 1) - 1;
         for (; iv < ivmax;) {
             vertices[++iv] = px;
             vertices[++iv] = py;
             steps[++is] = strokeWidth;
-            steps[++is] = scaleInvariant;
-            steps[++is] = pprevx;
-            steps[++is] = pprevy;
-            steps[++is] = pnextx;
-            steps[++is] = pnexty;
-            colorFills[++icf] = l;
-            colorFills[++icf] = dash0;
-            colorFills[++icf] = dash1;
-            colorFills[++icf] = -1;
+            steps[++is] = e3;
+            steps[++is] = d;
+            steps[++is] = l;
+            steps[++is] = -l;
+            steps[++is] = 0;
+            vertices[++iv] = px;
+            vertices[++iv] = py;
+            steps[++is] = strokeWidth;
+            steps[++is] = e5;
+            steps[++is] = d;
+            steps[++is] = l;
+            steps[++is] = -l;
+            steps[++is] = 0;
         }
     }
     return l;