pxt-common-packages 12.3.2 → 12.3.4

package/libs/screen/sim/image.ts

@@ -933,6 +933,412 @@ namespace pxsim.ImageMethods {
         }
         return false;
     }
+
+    const TWO_PI = 2 * Math.PI;
+    const HALF_PI = Math.PI / 2;
+    const THREE_HALF_PI = 3 * Math.PI / 2
+
+    const FX_ONE = 1;
+
+    function fxMul(a: number, b: number) {
+        return (a * b)
+    }
+
+    function fxDiv(a: number, b: number) {
+        return a / b;
+    }
+
+    function fxToInt(v: number) {
+        return v
+    }
+
+    function fxFloor(v: number) {
+        return v | 0;
+    }
+
+    interface ParsedShearArgs {
+        sx: number;
+        sy: number;
+        scaledWidth: number;
+        scaledHeight: number;
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+        xShear: number;
+        yShear: number;
+        flip: boolean;
+    }
+
+    function parseShearArgs(src: RefImage, args: RefCollection, argIndex: number): ParsedShearArgs {
+        const parsed: ParsedShearArgs = {
+            sx: 0,
+            sy: 0,
+            scaledWidth: 0,
+            scaledHeight: 0,
+            minX: 0,
+            minY: 0,
+            maxX: 0,
+            maxY: 0,
+            xShear: 0,
+            yShear: 0,
+            flip: false
+        };
+
+        const sx = ((args.getAt(argIndex) as number) * FX_ONE);
+        const sy = ((args.getAt(argIndex + 1) as number) * FX_ONE);
+        let angle = args.getAt(argIndex + 2) as number;
+
+        parsed.sx = sx;
+        parsed.sy = sy;
+
+        if (sx <= 0 || sy <= 0) {
+            return parsed;
+        }
+
+        angle %= TWO_PI;
+        if (angle < 0) {
+            angle += TWO_PI;
+        }
+
+        let flip = false;
+        if (angle > HALF_PI && angle <= THREE_HALF_PI) {
+            flip = true
+            angle = (angle + Math.PI) % TWO_PI
+        }
+
+        const xShear = (-Math.tan(angle / 2) * FX_ONE);
+        const yShear = (Math.sin(angle) * FX_ONE);
+
+        const scaledWidth = src._width * sx;
+        const scaledHeight = src._height * sy;
+
+        let shearedX = 0;
+        let shearedY = 0;
+
+        const SHEAR = (x: number, y: number) => {
+            shearedX = fxFloor(x + fxMul(y, xShear));
+            shearedY = fxFloor(y + fxMul(shearedX, yShear));
+            shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+        }
+
+        SHEAR(0, 0);
+        let minX = shearedX;
+        let minY = shearedY;
+        let maxX = shearedX;
+        let maxY = shearedY;
+
+        SHEAR(scaledWidth - FX_ONE, 0);
+        minX = Math.min(minX, shearedX);
+        minY = Math.min(minY, shearedY);
+        maxX = Math.max(maxX, shearedX);
+        maxY = Math.max(maxY, shearedY);
+
+        SHEAR(scaledWidth - FX_ONE, scaledHeight - FX_ONE);
+        minX = Math.min(minX, shearedX);
+        minY = Math.min(minY, shearedY);
+        maxX = Math.max(maxX, shearedX);
+        maxY = Math.max(maxY, shearedY);
+
+        SHEAR(0, scaledHeight - FX_ONE);
+        minX = Math.min(minX, shearedX);
+        minY = Math.min(minY, shearedY);
+        maxX = Math.max(maxX, shearedX);
+        maxY = Math.max(maxY, shearedY);
+
+        parsed.minX = minX;
+        parsed.minY = minY;
+        parsed.maxX = maxX;
+        parsed.maxY = maxY;
+        parsed.scaledWidth = scaledWidth;
+        parsed.scaledHeight = scaledHeight;
+        parsed.xShear = xShear;
+        parsed.yShear = yShear;
+        parsed.flip = flip;
+
+        return parsed;
+    }
+
+    export function _drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection) {
+        drawScaledRotatedImage(dst, src, args);
+    }
+
+    export function drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection) {
+        const xDst = args.getAt(0) as number;
+        const yDst = args.getAt(1) as number;
+        if (xDst >= dst._width || yDst >= dst._height) {
+            return;
+        }
+
+        const shearArgs = parseShearArgs(src, args, 2);
+
+        if (
+            shearArgs.sx <= 0 ||
+            shearArgs.sy <= 0 ||
+            xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+            yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0
+        ) {
+            return;
+        }
+
+        let shearedX = 0;
+        let shearedY = 0;
+
+        const SHEAR = (x: number, y: number) => {
+            shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+            shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+            shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+        }
+
+        dst.makeWritable();
+
+        if (shearArgs.flip) {
+            for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)),
+                        fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y);
+                    setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                }
+            }
+        }
+        else {
+            for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv(x, shearArgs.sx)),
+                        fxToInt(fxDiv(y, shearArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y);
+                    setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                }
+            }
+        }
+    }
+
+    export function _checkOverlapsScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): boolean {
+        const xDst = args.getAt(0) as number;
+        const yDst = args.getAt(1) as number;
+        if (xDst >= dst._width || yDst >= dst._height) {
+            return false;
+        }
+
+        const shearArgs = parseShearArgs(src, args, 2);
+
+        if (
+            shearArgs.sx <= 0 ||
+            shearArgs.sy <= 0 ||
+            xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+            yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0
+        ) {
+            return false;
+        }
+
+        let shearedX = 0;
+        let shearedY = 0;
+
+        const SHEAR = (x: number, y: number) => {
+            shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+            shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+            shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+        }
+
+
+        if (shearArgs.flip) {
+            for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)),
+                        fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y);
+                    if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else {
+            for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv(x, shearArgs.sx)),
+                        fxToInt(fxDiv(y, shearArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y);
+                    if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    export function _checkOverlapsTwoScaledRotatedImages(dst: RefImage, src: RefImage, args: RefCollection): boolean {
+        const xDst = args.getAt(0) as number;
+        const yDst = args.getAt(1) as number;
+        const dstArgs = parseShearArgs(dst, args, 2);
+
+        if (
+            dstArgs.sx <= 0 ||
+            dstArgs.sy <= 0 ||
+            xDst >= dstArgs.maxX - dstArgs.minX ||
+            yDst >= dstArgs.maxY - dstArgs.minY
+        ) {
+            return false;
+        }
+
+        const srcArgs = parseShearArgs(src, args, 5);
+
+        if (
+            srcArgs.sx <= 0 ||
+            srcArgs.sy <= 0 ||
+            xDst + srcArgs.maxX - srcArgs.minX < 0 ||
+            yDst + srcArgs.maxY - srcArgs.minY < 0
+        ) {
+            return false;
+        }
+
+        let shearedX = 0;
+        let shearedY = 0;
+        let unshearedX = 0;
+        let unshearedY = 0;
+
+        const SHEAR = (x: number, y: number, xShear: number, yShear: number) => {
+            shearedX = fxFloor(x + fxMul(y, xShear));
+            shearedY = fxFloor(y + fxMul(shearedX, yShear));
+            shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+        }
+
+        const REVERSE_SHEAR = (x: number, y: number, xShear: number, yShear: number) => {
+            unshearedX = fxFloor(x - fxMul(y, xShear));
+            unshearedY = fxFloor(y - fxMul(unshearedX, yShear));
+            unshearedX = fxFloor(unshearedX - fxMul(unshearedY, xShear));
+        }
+
+        if (srcArgs.flip) {
+            for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv((srcArgs.scaledWidth - x - FX_ONE), srcArgs.sx)),
+                        fxToInt(fxDiv((srcArgs.scaledHeight - y - FX_ONE), srcArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+
+                    const screenX = xDst + shearedX - srcArgs.minX;
+                    const screenY = yDst + shearedY - srcArgs.minY;
+
+                    if (
+                        screenX < 0 ||
+                        screenY < 0 ||
+                        screenX >= dstArgs.maxX - dstArgs.minX ||
+                        screenY >= dstArgs.maxY - dstArgs.minY
+                    ) {
+                        continue;
+                    }
+
+                    REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+
+                    if (dstArgs.flip) {
+                        if (
+                            getPixel(
+                                dst,
+                                fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)),
+                                fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy))
+                            )
+                        ) {
+                            return true;
+                        }
+                    }
+                    else if (
+                        getPixel(
+                            dst,
+                            fxToInt(fxDiv(unshearedX, dstArgs.sx)),
+                            fxToInt(fxDiv(unshearedY, dstArgs.sy))
+                        )
+                    ) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else {
+            for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                    let color = getPixel(
+                        src,
+                        fxToInt(fxDiv(x, srcArgs.sx)),
+                        fxToInt(fxDiv(y, srcArgs.sy))
+                    );
+
+                    if (!color) continue;
+
+                    SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+
+                    const screenX = xDst + shearedX - srcArgs.minX;
+                    const screenY = yDst + shearedY - srcArgs.minY;
+
+                    if (
+                        screenX < 0 ||
+                        screenY < 0 ||
+                        screenX >= dstArgs.maxX - dstArgs.minX ||
+                        screenY >= dstArgs.maxY - dstArgs.minY
+                    ) {
+                        continue;
+                    }
+
+                    REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+
+                    if (dstArgs.flip) {
+                        if (
+                            getPixel(
+                                dst,
+                                fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)),
+                                fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy))
+                            )
+                        ) {
+                            return true;
+                        }
+                    }
+                    else if (
+                        getPixel(
+                            dst,
+                            fxToInt(fxDiv(unshearedX, dstArgs.sx)),
+                            fxToInt(fxDiv(unshearedY, dstArgs.sy))
+                        )
+                    ) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }
 
 

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

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P52723(s) {
+function _main___P53420(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___52966 = (undefined);
-    globals._pollEventQueue___52979 = (undefined);
+    globals._intervals___53663 = (undefined);
+    globals._pollEventQueue___53676 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P52723.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"targetoverrides.ts","functionName":"<main>","argumentNames":[]}
-_main___P52723.continuations = [  ]
+_main___P53420.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"targetoverrides.ts","functionName":"<main>","argumentNames":[]}
+_main___P53420.continuations = [  ]
 
-function _main___P52723_mk(s) {
+function _main___P53420_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P52723, depth: s.depth + 1,
+        parent: s, fn: _main___P53420, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P52723_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P52723
+return _main___P53420
 })

package/libs/settings/pxt.json

@@ -12,6 +12,7 @@
         "RP2040Flash.cpp",
         "settings.cpp",
         "settings.ts",
+        "targetoverrides.ts",
         "shims.d.ts"
     ],
     "public": true,

package/libs/settings/settings.cpp

@@ -20,29 +20,26 @@ class WStorage {
     FS fs;
     bool isMounted;
 
-    WStorage()
+    WStorage(uint32_t size)
         : flash(),
 #if defined(STM32F4)
-          fs(flash, 0x8008000, SETTINGS_SIZE),
+          fs(flash, 0x8008000, size),
 #elif defined(SAMD51)
-          fs(flash, 512 * 1024 - SETTINGS_SIZE, SETTINGS_SIZE),
+          fs(flash, 512 * 1024 - size, size),
 #elif defined(SAMD21)
-          fs(flash, 256 * 1024 - SETTINGS_SIZE, SETTINGS_SIZE),
+          fs(flash, 256 * 1024 - size, size),
 #elif defined(MICROBIT_CODAL) && MICROBIT_CODAL
-          // micro:bit V2 memory map
-          // https://github.com/lancaster-university/codal-microbit-v2/blob/master/docs/MemoryMap.md
-          // 73000	CODAL scratch page (is used as temporary scratch by MicroBitFlash, MicroBitFileSystem and MicroBitStorage)
-          fs(flash, 0x73000 - SETTINGS_SIZE, SETTINGS_SIZE),
+          fs(flash, MICROBIT_TOP_OF_FLASH - size, size),
 #elif defined(NRF52_SERIES)
 #define NRF_BOOTLOADER_START *(uint32_t *)0x10001014
           fs(flash,
              128 * 1024 < NRF_BOOTLOADER_START && NRF_BOOTLOADER_START < (uint32_t)flash.totalSize()
-                 ? NRF_BOOTLOADER_START - SETTINGS_SIZE
-                 : flash.totalSize() - SETTINGS_SIZE,
-             SETTINGS_SIZE),
+                 ? NRF_BOOTLOADER_START - size
+                 : flash.totalSize() - size,
+                 size),
 #elif defined(PICO_BOARD)
           // XIP bias 0x10000000
-          fs(flash, 0x10000000 + flash.totalSize() - SETTINGS_SIZE - 4096, SETTINGS_SIZE),
+          fs(flash, 0x10000000 + flash.totalSize() - size - 4096, size),
 #else
           fs(flash),
 #endif
@@ -50,7 +47,18 @@ class WStorage {
         fs.minGCSpacing = 10000;
     }
 };
-SINGLETON(WStorage);
+
+static WStorage *instWStorage;
+WStorage *getWStorage() {
+    if (!instWStorage) {       
+        uint32_t size = getConfig(CFG_SETTINGS_SIZE_DEFL, SETTINGS_SIZE);
+        uint32_t new_size = getConfig(CFG_SETTINGS_SIZE, 0);
+        if (new_size > 0)
+            size = new_size;
+        instWStorage = new WStorage(size);    
+    }
+    return instWStorage;
+}
 
 static WStorage *mountedStorage() {
     auto s = getWStorage();

package/libs/settings/targetoverrides.ts

@@ -0,0 +1,6 @@
+// override this if you want different amount of flash used
+namespace config {
+    export const SETTINGS_SIZE_DEFL = (32*1024)
+    // export const SETTINGS_SIZE_DEFL = (2*1024)  // for SAMD21
+    // NRF flash page size is 4096, so must be multiple of 4096 on NRF
+}