pxt-arcade 1.13.11 → 1.13.13

package/built/common-sim.d.ts

@@ -1131,6 +1131,10 @@ declare namespace pxsim.ImageMethods {
     function _drawIcon(img: RefImage, icon: RefBuffer, xy: number, color: number): void;
     function fillCircle(img: RefImage, cx: number, cy: number, r: number, c: number): void;
     function _fillCircle(img: RefImage, cxy: number, r: number, c: number): void;
+    function fillTriangle(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, c: number): void;
+    function _fillTriangle(img: RefImage, args: RefCollection): void;
+    function fillPolygon4(img: RefImage, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, c: number): void;
+    function _fillPolygon4(img: RefImage, args: RefCollection): void;
     function _blitRow(img: RefImage, xy: number, from: RefImage, xh: number): void;
     function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
     function _blit(img: RefImage, src: RefImage, args: RefCollection): boolean;

package/built/common-sim.js

@@ -4301,6 +4301,193 @@ var pxsim;
             fillCircle(img, XX(cxy), YY(cxy), r, c);
         }
         ImageMethods._fillCircle = _fillCircle;
+        function nextYRange_Low(x, line, 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;
+            }
+        }
+        function nextYRange_HighUp(x, line, 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;
+            }
+        }
+        function nextYRange_HighDown(x, line, 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;
+            }
+        }
+        function initYRangeGenerator(X0, Y0, X1, Y1) {
+            const line = {
+                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;
+                }
+            }
+        }
+        function fillTriangle(img, x0, y0, x1, y1, x2, y2, c) {
+            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 = [
+                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);
+            const nextFuncList = [
+                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);
+            }
+        }
+        ImageMethods.fillTriangle = fillTriangle;
+        function _fillTriangle(img, args) {
+            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);
+        }
+        ImageMethods._fillTriangle = _fillTriangle;
+        function fillPolygon4(img, x0, y0, x1, y1, x2, y2, x3, y3, c) {
+            const 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);
+            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);
+            const nextFuncList = [
+                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 = {
+                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);
+            }
+        }
+        ImageMethods.fillPolygon4 = fillPolygon4;
+        function _fillPolygon4(img, args) {
+            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);
+        }
+        ImageMethods._fillPolygon4 = _fillPolygon4;
         function _blitRow(img, xy, from, xh) {
             blitRow(img, XX(xy), YY(xy), from, XX(xh), YY(xh));
         }