pxt-common-packages 10.3.18 → 10.3.20

package/built/common-sim.d.ts

@@ -947,6 +947,20 @@ declare namespace pxsim.music {
     function queuePlayInstructions(when: number, b: RefBuffer): void;
     function stopPlaying(): void;
     function forceOutput(mode: number): void;
+    const SEQUENCER_STOP_MESSAGE = 3243;
+    const SEQUENCER_TICK_MESSAGE = 3244;
+    const SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+    const SEQUENCER_LOOPED_MESSAGE = 3246;
+    function _createSequencer(): Promise<number>;
+    function _sequencerState(id: number): string;
+    function _sequencerCurrentTick(id: number): number;
+    function _sequencerPlaySong(id: number, song: RefBuffer, loop: boolean): void;
+    function _sequencerStop(id: number): void;
+    function _sequencerSetVolume(id: number, volume: number): void;
+    function _sequencerSetVolumeForAll(volume: number): void;
+    function _sequencerSetTrackVolume(id: number, trackIndex: number, volume: number): void;
+    function _sequencerSetDrumTrackVolume(id: number, trackIndex: number, drumIndex: number, volume: number): void;
+    function _sequencerDispose(id: number): void;
 }
 declare namespace pxsim.mouse {
     function setButton(button: number, down: boolean): void;
@@ -1117,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

@@ -3200,10 +3200,108 @@ var pxsim;
         music.queuePlayInstructions = queuePlayInstructions;
         function stopPlaying() {
             pxsim.AudioContextManager.muteAllChannels();
+            if (sequencers) {
+                for (const seq of sequencers) {
+                    seq.sequencer.stop();
+                    seq.sequencer.dispose();
+                }
+            }
         }
         music.stopPlaying = stopPlaying;
         function forceOutput(mode) { }
         music.forceOutput = forceOutput;
+        music.SEQUENCER_STOP_MESSAGE = 3243;
+        music.SEQUENCER_TICK_MESSAGE = 3244;
+        music.SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+        music.SEQUENCER_LOOPED_MESSAGE = 3246;
+        let sequencers;
+        let nextSequencerId = 0;
+        async function _createSequencer() {
+            if (!sequencers) {
+                pxsim.AudioContextManager.onStopAll(() => {
+                    for (const seq of sequencers) {
+                        seq.sequencer.stop();
+                        seq.sequencer.dispose();
+                    }
+                    sequencers = [];
+                });
+                sequencers = [];
+            }
+            const res = {
+                id: nextSequencerId++,
+                sequencer: new music.Sequencer()
+            };
+            sequencers.push(res);
+            await res.sequencer.initAsync();
+            res.sequencer.addEventListener("stop", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_STOP_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("state-change", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_STATE_CHANGE_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("looped", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_LOOPED_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("tick", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_TICK_MESSAGE, this.id);
+            });
+            return res.id;
+        }
+        music._createSequencer = _createSequencer;
+        function _sequencerState(id) {
+            var _a;
+            return (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.state();
+        }
+        music._sequencerState = _sequencerState;
+        function _sequencerCurrentTick(id) {
+            var _a;
+            return (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.currentTick();
+        }
+        music._sequencerCurrentTick = _sequencerCurrentTick;
+        function _sequencerPlaySong(id, song, loop) {
+            var _a;
+            const decoded = music.decodeSong(song.data);
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.start(decoded, loop);
+        }
+        music._sequencerPlaySong = _sequencerPlaySong;
+        function _sequencerStop(id) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.stop();
+        }
+        music._sequencerStop = _sequencerStop;
+        function _sequencerSetVolume(id, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setVolume(volume);
+        }
+        music._sequencerSetVolume = _sequencerSetVolume;
+        function _sequencerSetVolumeForAll(volume) {
+            for (const seq of sequencers) {
+                seq.sequencer.setVolume(volume);
+            }
+        }
+        music._sequencerSetVolumeForAll = _sequencerSetVolumeForAll;
+        function _sequencerSetTrackVolume(id, trackIndex, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setTrackVolume(trackIndex, volume);
+        }
+        music._sequencerSetTrackVolume = _sequencerSetTrackVolume;
+        function _sequencerSetDrumTrackVolume(id, trackIndex, drumIndex, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setDrumTrackVolume(trackIndex, drumIndex, volume);
+        }
+        music._sequencerSetDrumTrackVolume = _sequencerSetDrumTrackVolume;
+        function _sequencerDispose(id) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.dispose();
+            sequencers = sequencers.filter(s => s.id !== id);
+        }
+        music._sequencerDispose = _sequencerDispose;
+        function lookupSequencer(id) {
+            for (const seq of sequencers)
+                if (seq.id === id)
+                    return seq.sequencer;
+            return undefined;
+        }
     })(music = pxsim.music || (pxsim.music = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
@@ -4203,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));
         }