pxt-common-packages 10.4.4 → 10.4.6

package/libs/screen/image.cpp

@@ -1159,6 +1159,232 @@ void _fillCircle(Image_ img, int cxy, int r, int c) {
     fillCircle(img, XX(cxy), YY(cxy), r, c);
 }
 
+typedef struct
+{
+    int x, y;
+    int x0, y0;
+    int x1, y1;
+    int W,H;
+    int dx, dy;
+    int yi, xi;
+    int D;
+    int nextFuncIndex;
+} LineGenState; // For keeping track of the state when generating Y values for a line, even when moving to the next X.
+
+typedef struct
+{
+    int min;
+    int max;
+} ValueRange;
+
+void nextYRange_Low(int x, LineGenState *line, ValueRange *yRange) {
+    while (line->x == x && line->x <= line->x1 && line->x < line->W) {
+        if (0 <= line->x) {
+            if (line->y < yRange->min) yRange->min = line->y;
+            if (line->y > yRange->max) yRange->max = line->y;
+        }
+        if (line->D > 0) {
+            line->y += line->yi;
+            line->D -= line->dx;
+        }
+        line->D += line->dy;
+        ++line->x;
+    }
+}
+
+void nextYRange_HighUp(int x, LineGenState *line, ValueRange *yRange) {
+    while (line->x == x && line->y >= line->y1 && line->x < line->W) {
+        if (0 <= line->x) {
+            if (line->y < yRange->min) yRange->min = line->y;
+            if (line->y > yRange->max) yRange->max = line->y;
+        }
+        if (line->D > 0) {
+            line->x += line->xi;
+            line->D += line->dy;
+        }
+        line->D += line->dx;
+        --line->y;
+    }
+}
+// This function is similar to the sub-function drawLineHigh for drawLine. However, it yields back after calculating all Y values of a given X. When the function is called again, it continues from the state where it yielded back previously.
+void nextYRange_HighDown(int x, LineGenState *line, ValueRange *yRange) {
+    while (line->x == x && line->y <= line->y1 && line->x < line->W) {
+        if (0 <= line->x) {
+            if (line->y < yRange->min) yRange->min = line->y;
+            if (line->y > yRange->max) yRange->max = line->y;
+        }
+        if (line->D > 0) {
+            line->x += line->xi;
+            line->D -= line->dy;
+        }
+        line->D += line->dx;
+        ++line->y;
+    }
+}
+
+LineGenState initYRangeGenerator(int16_t X0, int16_t Y0, int16_t X1, int16_t Y1) {
+    LineGenState line;
+
+    line.x0 = X0, line.y0 = Y0, line.x1 = X1, line.y1 = Y1;
+
+    line.dx = line.x1 - line.x0;
+    line.dy = line.y1 - line.y0;
+    line.y = line.y0;
+    line.x = line.x0;
+
+    if ((line.dy < 0 ? -line.dy : line.dy) < line.dx) {
+        line.yi = 1;
+        if (line.dy < 0) {
+            line.yi = -1;
+            line.dy = -line.dy;
+        }
+        line.D = 2 * line.dy - line.dx;
+        line.dx <<= 1;
+        line.dy <<= 1;
+
+        line.nextFuncIndex = 0;
+        return line;
+    } else {
+        line.xi = 1;
+        // if (dx < 0) {//should not hit
+        //     PANIC();
+        // }
+        if (line.dy < 0) {
+            line.D = 2 * line.dx + line.dy;
+            line.dx <<= 1;
+            line.dy <<= 1;
+
+            line.nextFuncIndex = 1;
+            return line;
+        } else {
+            line.D = 2 * line.dx - line.dy;
+            line.dx <<= 1;
+            line.dy <<= 1;
+
+            line.nextFuncIndex = 2;
+            return line;
+        }
+    }
+}
+
+void fillTriangle(Image_ img, int x0, int y0, int x1, int y1, int x2, int y2, int c) {
+    if (x1 < x0) {
+        swap(x0, x1);
+        swap(y0, y1);
+    }
+    if (x2 < x1) {
+        swap(x1, x2);
+        swap(y1, y2);
+    }
+    if (x1 < x0) {
+        swap(x0, x1);
+        swap(y0, y1);
+    }
+
+    LineGenState lines[] = {
+        initYRangeGenerator(x0, y0, x2, y2),
+        initYRangeGenerator(x0, y0, x1, y1),
+        initYRangeGenerator(x1, y1, x2, y2)
+    };
+
+    lines[0].W = lines[1].W = lines[2].W = width(img);
+    lines[0].H = lines[1].H = lines[2].H = height(img);
+
+    // We have 3 different sub-functions to generate Ys of edges, each particular edge maps to one of them.
+    // Use function pointers to avoid judging which function to call at every X.
+    typedef void (*FP_NEXT)(int x, LineGenState *line, ValueRange *yRange);
+    FP_NEXT nextFuncList[] = { nextYRange_Low, nextYRange_HighUp, nextYRange_HighDown };
+    FP_NEXT fpNext0 = nextFuncList[lines[0].nextFuncIndex];
+    FP_NEXT fpNext1 = nextFuncList[lines[1].nextFuncIndex];
+    FP_NEXT fpNext2 = nextFuncList[lines[2].nextFuncIndex];
+
+    ValueRange yRange={lines[0].H,-1};
+
+    for (int x = lines[1].x0; x <= lines[1].x1; x++) {
+        yRange.min = lines[0].H; yRange.max = -1;
+        fpNext0(x, &lines[0], &yRange);
+        fpNext1(x, &lines[1], &yRange);
+        fillRect(img, x, yRange.min, 1, yRange.max - yRange.min + 1, c);
+    }
+
+    fpNext2(lines[2].x0, &lines[2], &yRange);
+
+    for (int x = lines[2].x0 + 1; x <= lines[2].x1; x++) {
+        yRange.min = lines[0].H; yRange.max = -1;
+        fpNext0(x, &lines[0], &yRange);
+        fpNext2(x, &lines[2], &yRange);
+        fillRect(img, x, yRange.min, 1, yRange.max - yRange.min + 1, c);
+    }
+}
+
+void fillPolygon4(Image_ img, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3, int c) {
+    LineGenState lines[] = {
+        (x0 < x1) ? initYRangeGenerator(x0, y0, x1, y1) : initYRangeGenerator(x1, y1, x0, y0),
+        (x1 < x2) ? initYRangeGenerator(x1, y1, x2, y2) : initYRangeGenerator(x2, y2, x1, y1),
+        (x2 < x3) ? initYRangeGenerator(x2, y2, x3, y3) : initYRangeGenerator(x3, y3, x2, y2),
+        (x0 < x3) ? initYRangeGenerator(x0, y0, x3, y3) : initYRangeGenerator(x3, y3, x0, y0)};
+
+    lines[0].W = lines[1].W = lines[2].W = lines[3].W = width(img);
+    lines[0].H = lines[1].H = lines[2].H = lines[3].H = height(img);
+
+    int minX = min(min(x0, x1), min(x2, x3));
+    int maxX = min(max(max(x0, x1), max(x2, x3)), lines[0].W - 1);
+
+    typedef void (*FP_NEXT)(int x, LineGenState *line, ValueRange *yRange);
+    FP_NEXT nextFuncList[] = { nextYRange_Low, nextYRange_HighUp, nextYRange_HighDown };
+    FP_NEXT fpNext0 = nextFuncList[lines[0].nextFuncIndex];
+    FP_NEXT fpNext1 = nextFuncList[lines[1].nextFuncIndex];
+    FP_NEXT fpNext2 = nextFuncList[lines[2].nextFuncIndex];
+    FP_NEXT fpNext3 = nextFuncList[lines[3].nextFuncIndex];
+
+    ValueRange yRange = { lines[0].H, -1 };
+
+    for (int x = minX; x <= maxX; x++) {
+        yRange.min = lines[0].H; yRange.max = -1;
+        fpNext0(x, &lines[0], &yRange);
+        fpNext1(x, &lines[1], &yRange);
+        fpNext2(x, &lines[2], &yRange);
+        fpNext3(x, &lines[3], &yRange);
+        fillRect(img, x,yRange.min, 1, yRange.max - yRange.min + 1, c);
+    }
+}
+
+//%
+void _fillTriangle(Image_ img, pxt::RefCollection *args) {
+    fillTriangle(
+        img,
+        pxt::toInt(args->getAt(0)),
+        pxt::toInt(args->getAt(1)),
+        pxt::toInt(args->getAt(2)),
+        pxt::toInt(args->getAt(3)),
+        pxt::toInt(args->getAt(4)),
+        pxt::toInt(args->getAt(5)),
+        pxt::toInt(args->getAt(6))
+    );
+}
+
+// This polygon fill is similar to fillTriangle(): Scan minY and maxY of all edges at each X, and draw a vertical line between (x,minY)~(x,maxY).
+// The main difference is that it sorts the endpoints of each edge, x0 < x1, to draw from left to right, but doesn't sort the edges as it's too time consuming.
+// Instead, just call next(), which returns immediately if the x is not in range of the edge in horizon.
+// NOTE: Unlike triangles, edges of a polygon can cross a vertical line at a given X multi time. This algorithm can fill correctly only if edges meet this condition: Any vertical line(x) cross edges at most 2 times.
+// Fortunately, no matter what perspective transform is applied, a rectangle/trapezoid will still meet this condition.
+// Ref: https://forum.makecode.com/t/new-3d-engine-help-filling-4-sided-polygons/18641/9
+//%
+void _fillPolygon4(Image_ img, pxt::RefCollection *args) {
+    fillPolygon4(
+        img,
+        pxt::toInt(args->getAt(0)),
+        pxt::toInt(args->getAt(1)),
+        pxt::toInt(args->getAt(2)),
+        pxt::toInt(args->getAt(3)),
+        pxt::toInt(args->getAt(4)),
+        pxt::toInt(args->getAt(5)),
+        pxt::toInt(args->getAt(6)),
+        pxt::toInt(args->getAt(7)),
+        pxt::toInt(args->getAt(8))
+    );
+}
+
 } // namespace ImageMethods
 
 namespace image {

package/libs/screen/image.ts

@@ -67,6 +67,18 @@ interface Image {
     //% helper=imageFillCircle
     fillCircle(cx: number, cy: number, r: number, c: color): void;
 
+    /**
+     * Fills a triangle
+     */
+    //% helper=imageFillTriangle
+    fillTriangle(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, col: number): void;
+
+    /**
+     * Fills a 4-side-polygon
+     */
+    //% helper=imageFillPolygon4
+    fillPolygon4(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, col: number): void;
+
     /**
      * Returns an image rotated by -90, 0, 90, 180, 270 deg clockwise
      */
@@ -128,6 +140,12 @@ namespace helpers {
     //% shim=ImageMethods::_blit
     declare function _blit(img: Image, src: Image, args: number[]): boolean;
 
+    //% shim=ImageMethods::_fillTriangle
+    declare function _fillTriangle(img: Image, args: number[]): void;
+
+    //% shim=ImageMethods::_fillPolygon4
+    declare function _fillPolygon4(img: Image, args: number[]): void;
+
     function pack(x: number, y: number) {
         return (Math.clamp(-30000, 30000, x | 0) & 0xffff) | (Math.clamp(-30000, 30000, y | 0) << 16)
     }
@@ -211,6 +229,32 @@ namespace helpers {
         _fillCircle(img, pack(cx, cy), r, col);
     }
 
+    export function imageFillTriangle(img: Image, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, col: number) {
+        _blitArgs = _blitArgs || [];
+        _blitArgs[0] = x0;
+        _blitArgs[1] = y0;
+        _blitArgs[2] = x1;
+        _blitArgs[3] = y1;
+        _blitArgs[4] = x2;
+        _blitArgs[5] = y2;
+        _blitArgs[6] = col;
+        _fillTriangle(img, _blitArgs);
+    }
+
+    export function imageFillPolygon4(img: Image, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, col: number) {
+        _blitArgs = _blitArgs || [];
+        _blitArgs[0] = x0;
+        _blitArgs[1] = y0;
+        _blitArgs[2] = x1;
+        _blitArgs[3] = y1;
+        _blitArgs[4] = x2;
+        _blitArgs[5] = y2;
+        _blitArgs[6] = x3;
+        _blitArgs[7] = y3;
+        _blitArgs[8] = col;
+        _fillPolygon4(img, _blitArgs);
+    }
+
     /**
      * Returns an image rotated by 90, 180, 270 deg clockwise
      */

package/libs/screen/sim/image.ts

@@ -612,6 +612,246 @@ namespace pxsim.ImageMethods {
         fillCircle(img, XX(cxy), YY(cxy), r, c);
     }
 
+    interface LineGenState {
+        x: number;
+        y: number;
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+        W: number;
+        H: number;
+        dx: number;
+        dy: number;
+        yi: number;
+        xi: number;
+        D: number;
+        nextFuncIndex: number;
+    }
+    interface ValueRange {
+        min: number;
+        max: number;
+    }
+
+    function nextYRange_Low(x: number, line: LineGenState, yRange: ValueRange) {
+        while (line.x === x && line.x <= line.x1 && line.x < line.W) {
+            if (0 <= line.x) {
+                if (line.y < yRange.min) yRange.min = line.y;
+                if (line.y > yRange.max) yRange.max = line.y
+            }
+            if (line.D > 0) {
+                line.y += line.yi;
+                line.D -= line.dx;
+            }
+            line.D += line.dy;
+            ++line.x;
+        }
+    }
+
+    function nextYRange_HighUp(x: number, line: LineGenState, yRange: ValueRange) {
+        while (line.x == x && line.y >= line.y1 && line.x < line.W) {
+            if (0 <= line.x) {
+                if (line.y < yRange.min) yRange.min = line.y;
+                if (line.y > yRange.max) yRange.max = line.y;
+            }
+            if (line.D > 0) {
+                line.x += line.xi;
+                line.D += line.dy;
+            }
+            line.D += line.dx;
+            --line.y;
+        }
+    }
+
+    function nextYRange_HighDown(x: number, line: LineGenState, yRange: ValueRange) {
+        while (line.x == x && line.y <= line.y1 && line.x < line.W) {
+            if (0 <= line.x) {
+                if (line.y < yRange.min) yRange.min = line.y;
+                if (line.y > yRange.max) yRange.max = line.y;
+            }
+            if (line.D > 0) {
+                line.x += line.xi;
+                line.D -= line.dy;
+            }
+            line.D += line.dx;
+            ++line.y;
+        }
+    }
+
+    function initYRangeGenerator(X0: number, Y0: number, X1: number, Y1: number): LineGenState {
+        const line: LineGenState = {
+            x: X0,
+            y: Y0,
+            x0: X0,
+            y0: Y0,
+            x1: X1,
+            y1: Y1,
+            W: 0,
+            H: 0,
+            dx: X1 - X0,
+            dy: Y1 - Y0,
+            yi: 0,
+            xi: 0,
+            D: 0,
+            nextFuncIndex: 0,
+        };
+
+        if ((line.dy < 0 ? -line.dy : line.dy) < line.dx) {
+            line.yi = 1;
+            if (line.dy < 0) {
+                line.yi = -1;
+                line.dy = -line.dy;
+            }
+            line.D = 2 * line.dy - line.dx;
+            line.dx = line.dx << 1;
+            line.dy = line.dy << 1;
+
+            line.nextFuncIndex = 0;
+            return line;
+        } else {
+            line.xi = 1;
+            if (line.dy < 0) {
+                line.D = 2 * line.dx + line.dy;
+                line.dx = line.dx << 1;
+                line.dy = line.dy << 1;
+
+                line.nextFuncIndex = 1;
+                return line;
+            } else {
+                line.D = 2 * line.dx - line.dy;
+                line.dx = line.dx << 1;
+                line.dy = line.dy << 1;
+
+                line.nextFuncIndex = 2;
+                return line;
+            }
+        }
+    }
+
+    export function fillTriangle(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, c: number) {
+        if (x1 < x0) {
+            [x1, x0] = [x0, x1];
+            [y1, y0] = [y0, y1];
+        }
+        if (x2 < x1) {
+            [x2, x1] = [x1, x2];
+            [y2, y1] = [y1, y2];
+        }
+        if (x1 < x0) {
+            [x1, x0] = [x0, x1];
+            [y1, y0] = [y0, y1];
+        }
+
+        const lines: LineGenState[] = [
+            initYRangeGenerator(x0, y0, x2, y2),
+            initYRangeGenerator(x0, y0, x1, y1),
+            initYRangeGenerator(x1, y1, x2, y2)
+        ];
+
+        lines[0].W = lines[1].W = lines[2].W = width(img);
+        lines[0].H = lines[1].H = lines[2].H = height(img);
+
+        type FP_NEXT = (x: number, line: LineGenState, yRange: ValueRange) => void;
+        const nextFuncList: FP_NEXT[] = [
+            nextYRange_Low,
+            nextYRange_HighUp,
+            nextYRange_HighDown
+        ];
+        const fpNext0 = nextFuncList[lines[0].nextFuncIndex];
+        const fpNext1 = nextFuncList[lines[1].nextFuncIndex];
+        const fpNext2 = nextFuncList[lines[2].nextFuncIndex];
+
+        const yRange= {
+            min: lines[0].H,
+            max: -1
+        };
+
+        for (let x = lines[1].x0; x <= lines[1].x1; x++) {
+            yRange.min = lines[0].H; yRange.max = -1;
+            fpNext0(x, lines[0], yRange);
+            fpNext1(x, lines[1], yRange);
+            fillRect(img, x, yRange.min, 1, yRange.max - yRange.min + 1, c);
+        }
+
+        fpNext2(lines[2].x0, lines[2], yRange);
+
+        for (let x = lines[2].x0 + 1; x <= lines[2].x1; x++) {
+            yRange.min = lines[0].H; yRange.max = -1;
+            fpNext0(x, lines[0], yRange);
+            fpNext2(x, lines[2], yRange);
+            fillRect(img, x, yRange.min, 1, yRange.max - yRange.min + 1, c);
+        }
+    }
+
+    export function _fillTriangle(img: RefImage, args: RefCollection) {
+        fillTriangle(
+            img,
+            args.getAt(0) | 0,
+            args.getAt(1) | 0,
+            args.getAt(2) | 0,
+            args.getAt(3) | 0,
+            args.getAt(4) | 0,
+            args.getAt(5) | 0,
+            args.getAt(6) | 0,
+        );
+    }
+
+    export function fillPolygon4(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, c: number) {
+        const lines: LineGenState[]= [
+            (x0 < x1) ? initYRangeGenerator(x0, y0, x1, y1) : initYRangeGenerator(x1, y1, x0, y0),
+            (x1 < x2) ? initYRangeGenerator(x1, y1, x2, y2) : initYRangeGenerator(x2, y2, x1, y1),
+            (x2 < x3) ? initYRangeGenerator(x2, y2, x3, y3) : initYRangeGenerator(x3, y3, x2, y2),
+            (x0 < x3) ? initYRangeGenerator(x0, y0, x3, y3) : initYRangeGenerator(x3, y3, x0, y0)
+        ];
+
+        lines[0].W = lines[1].W = lines[2].W = lines[3].W = width(img);
+        lines[0].H = lines[1].H = lines[2].H = lines[3].H = height(img);
+
+        let minX = Math.min(Math.min(x0, x1), Math.min(x2, x3));
+        let maxX = Math.min(Math.max(Math.max(x0, x1), Math.max(x2, x3)), lines[0].W - 1);
+
+        type FP_NEXT = (x: number, line: LineGenState, yRange: ValueRange) => void;
+        const nextFuncList: FP_NEXT[] = [
+            nextYRange_Low,
+            nextYRange_HighUp,
+            nextYRange_HighDown
+        ];
+
+        const fpNext0 = nextFuncList[lines[0].nextFuncIndex];
+        const fpNext1 = nextFuncList[lines[1].nextFuncIndex];
+        const fpNext2 = nextFuncList[lines[2].nextFuncIndex];
+        const fpNext3 = nextFuncList[lines[3].nextFuncIndex];
+
+        const yRange: ValueRange = {
+            min: lines[0].H,
+            max: -1
+        };
+
+        for (let x = minX; x <= maxX; x++) {
+            yRange.min = lines[0].H; yRange.max = -1;
+            fpNext0(x, lines[0], yRange);
+            fpNext1(x, lines[1], yRange);
+            fpNext2(x, lines[2], yRange);
+            fpNext3(x, lines[3], yRange);
+            fillRect(img, x,yRange.min, 1, yRange.max - yRange.min + 1, c);
+        }
+    }
+
+    export function _fillPolygon4(img: RefImage, args: RefCollection) {
+        fillPolygon4(
+            img,
+            args.getAt(0) | 0,
+            args.getAt(1) | 0,
+            args.getAt(2) | 0,
+            args.getAt(3) | 0,
+            args.getAt(4) | 0,
+            args.getAt(5) | 0,
+            args.getAt(6) | 0,
+            args.getAt(7) | 0,
+            args.getAt(8) | 0,
+        );
+    }
+
     export function _blitRow(img: RefImage, xy: number, from: RefImage, xh: number) {
         blitRow(img, XX(xy), YY(xy), from, XX(xh), YY(xh))
     }

package/libs/servo/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P52784(s) {
+function _main___P52847(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___53027 = (undefined);
-    globals._pollEventQueue___53040 = (undefined);
+    globals._intervals___53090 = (undefined);
+    globals._pollEventQueue___53103 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P52784.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"targetoverrides.ts","functionName":"<main>","argumentNames":[]}
-_main___P52784.continuations = [  ]
+_main___P52847.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"targetoverrides.ts","functionName":"<main>","argumentNames":[]}
+_main___P52847.continuations = [  ]
 
-function _main___P52784_mk(s) {
+function _main___P52847_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P52784, depth: s.depth + 1,
+        parent: s, fn: _main___P52847, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P52784_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P52784
+return _main___P52847
 })

package/libs/sprite-scaling/_locales/sprite-scaling-jsdoc-strings.json

@@ -1 +1,18 @@
-{}
+{
+  "scaling.scaleByPercent": "Scale a sprite by a percentage of its original size.",
+  "scaling.scaleByPercent|param|direction": "from the sprite anchor point, eg: ScaleDirection.Uniformly",
+  "scaling.scaleByPercent|param|sprite": "to scale to a percentage of its original size",
+  "scaling.scaleByPercent|param|value": "that is the percentage to scale the sprite by, eg: 50",
+  "scaling.scaleByPixels": "Scale a sprite by a number of pixels.",
+  "scaling.scaleByPixels|param|direction": "from the sprite anchor point, eg: ScaleDirection.Horizontally",
+  "scaling.scaleByPixels|param|sprite": "to scale to new pixel size",
+  "scaling.scaleByPixels|param|value": "that is the number of pixels to scale the sprite by, eg: 10",
+  "scaling.scaleToPercent": "Scale a sprite to a percentage of its original size.",
+  "scaling.scaleToPercent|param|direction": "from the sprite anchor point, eg: ScaleDirection.Uniformly",
+  "scaling.scaleToPercent|param|sprite": "to scale to a percentage of its original size",
+  "scaling.scaleToPercent|param|value": "that is the percentage to scale the sprite, eg: 150",
+  "scaling.scaleToPixels": "Scale a sprite to a number of pixels.",
+  "scaling.scaleToPixels|param|direction": "from the sprite anchor point, eg: ScaleDirection.Horizontally",
+  "scaling.scaleToPixels|param|sprite": "to scale to new pixel size",
+  "scaling.scaleToPixels|param|value": "that is the number of pixels to scale the sprite to, eg: 32"
+}

package/libs/sprite-scaling/_locales/sprite-scaling-strings.json

@@ -3,5 +3,6 @@
   "scaling.scaleByPixels|block": "change $sprite=variables_get(mySprite) scale by $value pixels $direction anchor $anchor || proportional $proportional",
   "scaling.scaleToPercent|block": "set $sprite=variables_get(mySprite) scale to $value percent $direction anchor $anchor",
   "scaling.scaleToPixels|block": "set $sprite=variables_get(mySprite) scale to $value pixels $direction anchor $anchor || proportional $proportional",
+  "scaling|block": "scaling",
   "{id:category}Scaling": "Scaling"
 }