pxt-core 7.5.8 → 7.5.9

package/built/pxtlib.js

@@ -15844,7 +15844,8 @@ var ts;
             "topblock",
             "callInDebugger",
             "duplicateShadowOnDrag",
-            "argsNullable"
+            "argsNullable",
+            "compileHiddenArguments"
         ];
         function parseCommentString(cmt) {
             let res = {
@@ -16762,6 +16763,125 @@ var pxt;
         skillmap.IndexedDBWorkspace = IndexedDBWorkspace;
     })(skillmap = pxt.skillmap || (pxt.skillmap = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var assets;
+    (function (assets) {
+        function renderSoundPath(sound, width, height) {
+            const { startFrequency, endFrequency, startVolume, endVolume, wave, interpolation } = sound;
+            const scale = (start, end, percent) => {
+                return Math.pow(start, 1 - percent) * Math.pow(end, percent);
+            };
+            // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
+            // The numbers are still nonsense but at least this reflects that it's deterministic.
+            const random = new SeededRandom(startFrequency + endFrequency + 1);
+            let getFrequencyAt;
+            switch (interpolation) {
+                case "linear":
+                    getFrequencyAt = x => startFrequency + x * (endFrequency - startFrequency) / width;
+                    break;
+                case "curve":
+                    getFrequencyAt = x => startFrequency + (endFrequency - startFrequency) * Math.sin(x / width * (Math.PI / 2));
+                    break;
+                case "logarithmic":
+                    getFrequencyAt = x => startFrequency + Math.log10(1 + 9 * (x / width)) * (endFrequency - startFrequency);
+                    break;
+            }
+            if (wave === "noise") {
+                getFrequencyAt = () => random.randomRange(500, 1000);
+            }
+            const getVolumeAt = (x) => ((endVolume - startVolume) / width) * x + startVolume;
+            const volumeToAmplitude = (volume) => (volume / 1023) * (height - 2) / 2;
+            const frequencyToWidth = (frequency) => Math.min(width, Math.max(10, (1 / scale(1, 4000, frequency / 4000)) * width / 2));
+            const parts = [`M ${2} ${height / 2}`];
+            let currentX = 0;
+            while (currentX < width) {
+                parts.push(renderHalfWavePart(volumeToAmplitude(getVolumeAt(currentX)), frequencyToWidth(getFrequencyAt(currentX)) / 2, wave, false, random));
+                currentX += frequencyToWidth(getFrequencyAt(currentX)) / 2;
+                parts.push(renderHalfWavePart(volumeToAmplitude(getVolumeAt(currentX)), frequencyToWidth(getFrequencyAt(currentX)) / 2, wave, true, random));
+                currentX += frequencyToWidth(getFrequencyAt(currentX)) / 2;
+            }
+            return parts.join(" ");
+        }
+        assets.renderSoundPath = renderSoundPath;
+        function renderWaveSnapshot(frequency, volume, wave, width, height, timeBase) {
+            // To make the graph appear consistent with the implementation, use a seeded random for the noise waveform.
+            // The numbers are still nonsense but at least this reflects that it's deterministic.
+            const random = new SeededRandom(frequency);
+            if (wave === "noise")
+                frequency = random.randomRange(500, 1000);
+            const amplitude = (volume / 1023) * (height - 2) / 2;
+            const waveHalfWidth = (width / (frequency * timeBase / 1000)) / 2;
+            let numSegments = Math.ceil(width / (waveHalfWidth * 2));
+            if (numSegments % 2 === 1)
+                numSegments++;
+            // Center the wave because it makes an animation look better. The overflow will be clipped
+            // by the outer svg
+            const parts = [`M ${(width / 2) - (numSegments * waveHalfWidth)} ${height / 2}`];
+            let currentX = 0;
+            for (let i = 0; i < numSegments; i++) {
+                parts.push(renderHalfWavePart(amplitude, waveHalfWidth, wave, false, random));
+                currentX += waveHalfWidth;
+                parts.push(renderHalfWavePart(amplitude, waveHalfWidth, wave, true, random));
+                currentX += waveHalfWidth;
+            }
+            return parts.join(" ");
+        }
+        assets.renderWaveSnapshot = renderWaveSnapshot;
+        class SeededRandom {
+            constructor(seed) {
+                this.seed = seed;
+                this.lfsr = seed;
+            }
+            next() {
+                const n = this.lfsr = (this.lfsr >> 1) ^ ((-(this.lfsr & 1)) & 0xb400);
+                return n / 0xffff;
+            }
+            randomRange(min, max) {
+                return min + (max - min) * this.next();
+            }
+        }
+        function renderHalfWavePart(amplitude, width, wave, flip, random) {
+            switch (wave) {
+                case "triangle":
+                    return `l ${width / 2} ${flip ? amplitude : -amplitude} l ${width / 2} ${flip ? -amplitude : amplitude}`;
+                case "square":
+                    return `v ${flip ? amplitude : -amplitude} h ${width} v ${flip ? -amplitude : amplitude}`;
+                case "sawtooth":
+                    if (flip) {
+                        return `l ${width} ${amplitude} v ${-amplitude}`;
+                    }
+                    else {
+                        return `v ${-amplitude} l ${width} ${amplitude}`;
+                    }
+                case "sine":
+                    return `q ${width / 2} ${(flip ? amplitude : -amplitude) * 1.9} ${width} 0`;
+                case "noise":
+                    const outParts = [];
+                    const points = [];
+                    const slice = Math.min(4, width / 4);
+                    let positive = flip;
+                    for (let x = 0; x < width; x += slice) {
+                        points.push(random.randomRange(0, amplitude) * (positive ? 1 : -1));
+                        positive = !positive;
+                    }
+                    points[0] = flip ? amplitude : -amplitude;
+                    points[points.length - 1] = 0;
+                    let offset = 0;
+                    let x = 0;
+                    for (const point of points) {
+                        let dx = Math.min(slice, width - x);
+                        outParts.push(`v ${point - offset} h ${dx}`);
+                        offset = point;
+                        x += dx;
+                        if (x >= width)
+                            break;
+                    }
+                    return outParts.join(" ");
+            }
+        }
+    })(assets = pxt.assets || (pxt.assets = {}));
+})(pxt || (pxt = {}));
 // See https://github.com/microsoft/TouchDevelop-backend/blob/master/docs/streams.md
 var pxt;
 (function (pxt) {
@@ -17169,6 +17289,10 @@ var pxt;
                 cb(this.d);
                 return this.update();
             }
+            setD(d) {
+                this.setAttribute("d", d);
+                return this;
+            }
         }
         svgUtil.Path = Path;
         class Image extends Drawable {

package/built/pxtsim.d.ts

@@ -1528,6 +1528,228 @@ declare namespace pxsim.svg {
     function title(el: SVGElement, txt: string): SVGTitleElement;
     function toHtmlColor(c: number): string;
 }
+declare namespace pxsim.codal.music {
+    interface Progression {
+        interval: number[];
+        length: number;
+    }
+}
+declare namespace pxsim.codal.music.MusicalIntervals {
+    const chromaticInterval: number[];
+    const majorScaleInterval: number[];
+    const minorScaleInterval: number[];
+    const pentatonicScaleInterval: number[];
+    const majorTriadInterval: number[];
+    const minorTriadInterval: number[];
+    const diminishedInterval: number[];
+    const wholeToneInterval: number[];
+}
+declare namespace pxsim.codal.music.MusicalProgressions {
+    const chromatic: Progression;
+    const majorScale: Progression;
+    const minorScale: Progression;
+    const pentatonicScale: Progression;
+    const majorTriad: Progression;
+    const minorTriad: Progression;
+    const diminished: Progression;
+    const wholeTone: Progression;
+    /**
+     * Determine the frequency of a given note in a given progressions
+     *
+     * @param root The root frequency of the progression
+     * @param progression The Progression to use
+     * @param offset The offset (interval) of the note to generate
+     * @return The frequency of the note requested in Hz.
+     */
+    function calculateFrequencyFromProgression(root: number, progression: Progression, offset: number): number;
+}
+/**
+ * Adapted from lancaster-university/codal-microbit-v2
+ * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundEmojiSynthesizer.cpp
+ */
+declare namespace pxsim.codal.music {
+    const EMOJI_SYNTHESIZER_SAMPLE_RATE = 44100;
+    const EMOJI_SYNTHESIZER_TONE_WIDTH_F = 1024;
+    const EMOJI_SYNTHESIZER_TONE_WIDTH = 1024;
+    const EMOJI_SYNTHESIZER_BUFFER_SIZE = 512;
+    const EMOJI_SYNTHESIZER_TONE_EFFECT_PARAMETERS = 2;
+    const EMOJI_SYNTHESIZER_TONE_EFFECTS = 3;
+    const EMOJI_SYNTHESIZER_STATUS_ACTIVE = 1;
+    const EMOJI_SYNTHESIZER_STATUS_OUTPUT_SILENCE_AS_EMPTY = 2;
+    const EMOJI_SYNTHESIZER_STATUS_STOPPING = 4;
+    class SoundEmojiSynthesizer {
+        bufferSize: number;
+        buffer: number[];
+        sampleRate: number;
+        sampleRange: number;
+        samplesPerStep: number[];
+        samplesToWrite: number;
+        samplesWritten: number;
+        orMask: number;
+        frequency: number;
+        volume: number;
+        position: number;
+        status: number;
+        effectPointer: number;
+        effectBuffer: SoundEffect[];
+        get effect(): SoundEffect;
+        constructor(id: number, sampleRate?: number);
+        play(sound: SoundEffect[]): void;
+        nextSoundEffect(): boolean;
+        pull(): number[];
+        determineSampleCount(playoutTime: number): number;
+        totalDuration(): number;
+    }
+}
+/**
+ * Adapted from lancaster-university/codal-core
+ * https://github.com/lancaster-university/codal-core/blob/master/source/streams/Synthesizer.cpp#L54
+ */
+declare namespace pxsim.codal.music.Synthesizer {
+    function SineTone(arg: number[], position: number): number;
+    function SawtoothTone(arg: number[], position: number): number;
+    function TriangleTone(arg: number[], position: number): number;
+    function NoiseTone(arg: number[], position: number): number;
+    function SquareWaveTone(arg: number[], position: number): 0 | 1023;
+}
+/**
+ * Adapted from lancaster-university/codal-microbit-v2
+ * https://github.com/lancaster-university/codal-microbit-v2/blob/master/source/SoundSynthesizerEffects.cpp
+ */
+declare namespace pxsim.codal.music.SoundSynthesizerEffects {
+    /**
+     * Root Frequency Interpolation Effect Functions
+     */
+    function noInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function linearInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function logarithmicInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function curveInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function slowVibratoInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function warbleInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function vibratoInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function exponentialRisingInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function exponentialFallingInterpolation(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function appregrioAscending(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function appregrioDescending(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    /**
+     * Frequency Delta effects
+     */
+    function frequencyVibratoEffect(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    function volumeVibratoEffect(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    /**
+     * Volume Delta effects
+     */
+    /** Simple ADSR enveleope effect.
+     * parameter[0]: Centre volume
+     * parameter[1]: End volume
+     * effect.volume: start volume
+     */
+    function adsrVolumeEffect(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+    /**
+     * Simple volume ramp effect
+     * parameter[0]: End volume
+     * effect.volume: start volume
+     */
+    function volumeRampEffect(synth: SoundEmojiSynthesizer, context: ToneEffect): void;
+}
+declare namespace pxsim.codal.music {
+    enum WaveShape {
+        Sine = 0,
+        Sawtooth = 1,
+        Triangle = 2,
+        Square = 3,
+        Noise = 4
+    }
+    enum InterpolationEffect {
+        None = 0,
+        Linear = 1,
+        Curve = 2,
+        ExponentialRising = 5,
+        ExponentialFalling = 6,
+        ArpeggioRisingMajor = 8,
+        ArpeggioRisingMinor = 10,
+        ArpeggioRisingDiminished = 12,
+        ArpeggioRisingChromatic = 14,
+        ArpeggioRisingWholeTone = 16,
+        ArpeggioFallingMajor = 9,
+        ArpeggioFallingMinor = 11,
+        ArpeggioFallingDiminished = 13,
+        ArpeggioFallingChromatic = 15,
+        ArpeggioFallingWholeTone = 17,
+        Logarithmic = 18
+    }
+    enum Effect {
+        None = 0,
+        Vibrato = 1,
+        Tremolo = 2,
+        Warble = 3
+    }
+    class Sound {
+        src: string;
+        constructor();
+        get wave(): WaveShape;
+        set wave(value: WaveShape);
+        get volume(): number;
+        set volume(value: number);
+        get frequency(): number;
+        set frequency(value: number);
+        get duration(): number;
+        set duration(value: number);
+        get shape(): InterpolationEffect;
+        set shape(value: InterpolationEffect);
+        get endFrequency(): number;
+        set endFrequency(value: number);
+        get endVolume(): number;
+        set endVolume(value: number);
+        get steps(): number;
+        set steps(value: number);
+        get fx(): Effect;
+        set fx(value: Effect);
+        get fxParam(): number;
+        set fxParam(value: number);
+        get fxnSteps(): number;
+        set fxnSteps(value: number);
+        get frequencyRandomness(): number;
+        set frequencyRandomness(value: number);
+        get endFrequencyRandomness(): number;
+        set endFrequencyRandomness(value: number);
+        get volumeRandomness(): number;
+        set volumeRandomness(value: number);
+        get endVolumeRandomness(): number;
+        set endVolumeRandomness(value: number);
+        get durationRandomness(): number;
+        set durationRandomness(value: number);
+        get fxParamRandomness(): number;
+        set fxParamRandomness(value: number);
+        get fxnStepsRandomness(): number;
+        set fxnStepsRandomness(value: number);
+        copy(): Sound;
+        protected setValue(offset: number, value: number, length: number): void;
+        protected getValue(offset: number, length: number): number;
+    }
+    function __playSoundExpression(notes: string, waitTillDone: boolean): void;
+    function playSoundExpressionAsync(notes: string, isCancelled?: () => boolean, onPull?: (freq: number, volume: number) => void): Promise<void>;
+    function __stopSoundExpressions(): void;
+    interface TonePrint {
+        tonePrint: (arg: number[], position: number) => number;
+        parameter: number[];
+    }
+    interface ToneEffect {
+        effect: (synth: SoundEmojiSynthesizer, context: ToneEffect) => void;
+        step: number;
+        steps: number;
+        parameter: number[];
+        parameter_p: Progression[];
+    }
+    interface SoundEffect {
+        frequency: number;
+        volume: number;
+        duration: number;
+        tone: TonePrint;
+        effects: ToneEffect[];
+    }
+    function parseSoundExpression(soundChars: string, fx: SoundEffect): boolean;
+}
 declare namespace pxsim {
     class Button {
         id: number;