pxt-common-packages 12.3.2 → 12.3.4

package/built/common-sim.d.ts

@@ -1256,6 +1256,10 @@ declare namespace pxsim.ImageMethods {
     function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
     function _blit(img: RefImage, src: RefImage, args: RefCollection): boolean;
     function blit(dst: RefImage, src: RefImage, args: RefCollection): boolean;
+    function _drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): void;
+    function drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): void;
+    function _checkOverlapsScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): boolean;
+    function _checkOverlapsTwoScaledRotatedImages(dst: RefImage, src: RefImage, args: RefCollection): boolean;
 }
 declare namespace pxsim.image {
     function byteHeight(h: number, bpp: number): number;

package/built/common-sim.js

@@ -4977,6 +4977,281 @@ var pxsim;
             return false;
         }
         ImageMethods.blit = blit;
+        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, b) {
+            return (a * b);
+        }
+        function fxDiv(a, b) {
+            return a / b;
+        }
+        function fxToInt(v) {
+            return v;
+        }
+        function fxFloor(v) {
+            return v | 0;
+        }
+        function parseShearArgs(src, args, argIndex) {
+            const parsed = {
+                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) * FX_ONE);
+            const sy = (args.getAt(argIndex + 1) * FX_ONE);
+            let angle = args.getAt(argIndex + 2);
+            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, y) => {
+                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;
+        }
+        function _drawScaledRotatedImage(dst, src, args) {
+            drawScaledRotatedImage(dst, src, args);
+        }
+        ImageMethods._drawScaledRotatedImage = _drawScaledRotatedImage;
+        function drawScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            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, y) => {
+                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);
+                    }
+                }
+            }
+        }
+        ImageMethods.drawScaledRotatedImage = drawScaledRotatedImage;
+        function _checkOverlapsScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            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, y) => {
+                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;
+        }
+        ImageMethods._checkOverlapsScaledRotatedImage = _checkOverlapsScaledRotatedImage;
+        function _checkOverlapsTwoScaledRotatedImages(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            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, y, xShear, yShear) => {
+                shearedX = fxFloor(x + fxMul(y, xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+            };
+            const REVERSE_SHEAR = (x, y, xShear, yShear) => {
+                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;
+        }
+        ImageMethods._checkOverlapsTwoScaledRotatedImages = _checkOverlapsTwoScaledRotatedImages;
     })(ImageMethods = pxsim.ImageMethods || (pxsim.ImageMethods = {}));
 })(pxsim || (pxsim = {}));
 (function (pxsim) {