@akashic/headless-driver 2.13.2 → 2.13.4

package/lib/runner/v3/platform/graphics/canvas/AffineTransformer.d.ts

@@ -0,0 +1,9 @@
+export declare class AffineTransformer {
+    matrix: Float32Array;
+    constructor(rhs?: AffineTransformer);
+    scale(x: number, y: number): AffineTransformer;
+    translate(x: number, y: number): AffineTransformer;
+    transform(matrix: number[]): AffineTransformer;
+    setTransform(matrix: number[]): void;
+    copyFrom(rhs: AffineTransformer): AffineTransformer;
+}

package/lib/runner/v3/platform/graphics/canvas/AffineTransformer.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AffineTransformer = void 0;
+class AffineTransformer {
+    constructor(rhs) {
+        if (rhs) {
+            this.matrix = new Float32Array(rhs.matrix);
+        }
+        else {
+            this.matrix = new Float32Array([1, 0, 0, 1, 0, 0]);
+        }
+    }
+    scale(x, y) {
+        const m = this.matrix;
+        m[0] *= x;
+        m[1] *= x;
+        m[2] *= y;
+        m[3] *= y;
+        return this;
+    }
+    translate(x, y) {
+        const m = this.matrix;
+        m[4] += m[0] * x + m[2] * y;
+        m[5] += m[1] * x + m[3] * y;
+        return this;
+    }
+    transform(matrix) {
+        const m = this.matrix;
+        const a = matrix[0] * m[0] + matrix[1] * m[2];
+        const b = matrix[0] * m[1] + matrix[1] * m[3];
+        const c = matrix[2] * m[0] + matrix[3] * m[2];
+        const d = matrix[2] * m[1] + matrix[3] * m[3];
+        const e = matrix[4] * m[0] + matrix[5] * m[2] + m[4];
+        const f = matrix[4] * m[1] + matrix[5] * m[3] + m[5];
+        m[0] = a;
+        m[1] = b;
+        m[2] = c;
+        m[3] = d;
+        m[4] = e;
+        m[5] = f;
+        return this;
+    }
+    setTransform(matrix) {
+        const m = this.matrix;
+        m[0] = matrix[0];
+        m[1] = matrix[1];
+        m[2] = matrix[2];
+        m[3] = matrix[3];
+        m[4] = matrix[4];
+        m[5] = matrix[5];
+    }
+    copyFrom(rhs) {
+        this.matrix.set(rhs.matrix);
+        return this;
+    }
+}
+exports.AffineTransformer = AffineTransformer;

package/lib/runner/v3/platform/graphics/canvas/NodeCanvasContext.d.ts

@@ -0,0 +1,42 @@
+/** @ts-ignore */
+import type { CanvasRenderingContext2D, ImageData } from "canvas";
+import type { akashicEngine as g } from "../../../engineFiles";
+import { RenderingState } from "./RenderingState";
+export declare class NodeCanvasContext {
+    protected _context: CanvasRenderingContext2D;
+    protected _stateStack: RenderingState[];
+    protected _contextFillStyle: string;
+    protected _contextGlobalAlpha: number;
+    protected _contextGlobalCompositeOperation: string;
+    private _modifiedTransform;
+    constructor(context: CanvasRenderingContext2D);
+    set fillStyle(fillStyle: string);
+    get fillStyle(): string;
+    set globalAlpha(globalAlpha: number);
+    get globalAlpha(): number;
+    set globalCompositeOperation(operation: string);
+    get globalCompositeOperation(): string;
+    getCanvasRenderingContext2D(): CanvasRenderingContext2D;
+    clearRect(x: number, y: number, width: number, height: number): void;
+    save(): void;
+    restore(): void;
+    scale(x: number, y: number): void;
+    drawImage(surface: g.Surface, srcX: number, srcY: number, srcW: number, srcH: number, dstX: number, dstY: number, dstW: number, dstH: number): void;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    fillText(text: string, x: number, y: number, maxWidth: number): void;
+    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+    translate(x: number, y: number): void;
+    transform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+    setTransform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
+    setGlobalAlpha(globalAlpha: number): void;
+    getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+    putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
+    /**
+     * 描画の前処理。
+     * 描画を省略すべきであれば false を返す。
+     */
+    prerender(): boolean;
+    private pushState;
+    private popState;
+    private currentState;
+}

package/lib/runner/v3/platform/graphics/canvas/NodeCanvasContext.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasContext = void 0;
+const RenderingState_1 = require("./RenderingState");
+class NodeCanvasContext {
+    constructor(context) {
+        this._stateStack = [];
+        this._modifiedTransform = false;
+        this._context = context;
+        const state = new RenderingState_1.RenderingState();
+        this._contextFillStyle = state.fillStyle;
+        this._contextGlobalAlpha = state.globalAlpha;
+        this._contextGlobalCompositeOperation = state.globalCompositeOperation;
+        this.pushState(state);
+    }
+    set fillStyle(fillStyle) {
+        this.currentState().fillStyle = fillStyle;
+    }
+    get fillStyle() {
+        return this.currentState().fillStyle;
+    }
+    set globalAlpha(globalAlpha) {
+        this.currentState().globalAlpha = globalAlpha;
+    }
+    get globalAlpha() {
+        return this.currentState().globalAlpha;
+    }
+    set globalCompositeOperation(operation) {
+        this.currentState().globalCompositeOperation = operation;
+    }
+    get globalCompositeOperation() {
+        return this.currentState().globalCompositeOperation;
+    }
+    getCanvasRenderingContext2D() {
+        return this._context;
+    }
+    clearRect(x, y, width, height) {
+        this.prerender();
+        this._context.clearRect(x, y, width, height);
+    }
+    save() {
+        const state = new RenderingState_1.RenderingState(this.currentState());
+        this.pushState(state);
+    }
+    restore() {
+        this.popState();
+    }
+    scale(x, y) {
+        this.currentState().transformer.scale(x, y);
+        this._modifiedTransform = true;
+    }
+    drawImage(surface, srcX, srcY, srcW, srcH, dstX, dstY, dstW, dstH) {
+        if (this.prerender()) {
+            this._context.drawImage(surface._drawable, srcX, srcY, srcW, srcH, dstX, dstY, dstW, dstH);
+        }
+    }
+    fillRect(x, y, width, height) {
+        if (this.prerender()) {
+            this._context.fillRect(x, y, width, height);
+        }
+    }
+    fillText(text, x, y, maxWidth) {
+        if (this.prerender()) {
+            this._context.fillText(text, x, y, maxWidth);
+        }
+    }
+    strokeText(text, x, y, maxWidth) {
+        if (this.prerender()) {
+            this._context.strokeText(text, x, y, maxWidth);
+        }
+    }
+    translate(x, y) {
+        this.currentState().transformer.translate(x, y);
+        this._modifiedTransform = true;
+    }
+    transform(m11, m12, m21, m22, dx, dy) {
+        this.currentState().transformer.transform([m11, m12, m21, m22, dx, dy]);
+        this._modifiedTransform = true;
+    }
+    setTransform(m11, m12, m21, m22, dx, dy) {
+        this.currentState().transformer.setTransform([m11, m12, m21, m22, dx, dy]);
+        this._modifiedTransform = true;
+    }
+    setGlobalAlpha(globalAlpha) {
+        this.currentState().globalAlpha = globalAlpha;
+    }
+    getImageData(sx, sy, sw, sh) {
+        return this._context.getImageData(sx, sy, sw, sh);
+    }
+    putImageData(imagedata, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight) {
+        this._context.putImageData(imagedata, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
+    }
+    /**
+     * 描画の前処理。
+     * 描画を省略すべきであれば false を返す。
+     */
+    prerender() {
+        const currentState = this.currentState();
+        if (currentState.fillStyle !== this._contextFillStyle) {
+            this._context.fillStyle = currentState.fillStyle;
+            this._contextFillStyle = currentState.fillStyle;
+        }
+        if (currentState.globalAlpha !== this._contextGlobalAlpha) {
+            this._context.globalAlpha = currentState.globalAlpha;
+            this._contextGlobalAlpha = currentState.globalAlpha;
+        }
+        if (currentState.globalCompositeOperation !== this._contextGlobalCompositeOperation) {
+            this._context.globalCompositeOperation = currentState.globalCompositeOperation;
+            this._contextGlobalCompositeOperation = currentState.globalCompositeOperation;
+        }
+        if (this._modifiedTransform) {
+            this._modifiedTransform = false;
+            const transformer = currentState.transformer;
+            if (transformer.matrix[0] === 0 || transformer.matrix[3] === 0) {
+                // node-canvas 側の不具合? アフィン変換行列における拡大縮小の x, y の係数のいずれかが 0 の場合それ以降描画がされなくなる。
+                // そのためこれらの要素が 0 の際は context に対して変換行列を適用せず、描画をスキップする。
+                // @see https://github.com/Automattic/node-canvas/issues/702
+                return false;
+            }
+            // FIXME: canvas@2.11.2 時点で setTransform() の TypeScript の型定義が不足しているため暫定でコンパイルできるように修正
+            // @see https://github.com/Automattic/node-canvas/pull/2322
+            this._context.setTransform(transformer.matrix[0], transformer.matrix[1], transformer.matrix[2], transformer.matrix[3], transformer.matrix[4], transformer.matrix[5]);
+        }
+        return true;
+    }
+    pushState(state) {
+        this._stateStack.push(state);
+    }
+    popState() {
+        if (this._stateStack.length <= 1) {
+            return;
+        }
+        this._stateStack.pop();
+        this._modifiedTransform = true;
+    }
+    currentState() {
+        return this._stateStack[this._stateStack.length - 1];
+    }
+}
+exports.NodeCanvasContext = NodeCanvasContext;

package/lib/runner/v3/platform/graphics/canvas/NodeCanvasRenderer.d.ts

@@ -1,11 +1,12 @@
 /** @ts-ignore */
-import type { CanvasRenderingContext2D, ImageData } from "canvas";
+import type { ImageData } from "canvas";
 import type { akashicEngine as g } from "../../../engineFiles";
+import type { NodeCanvasContext } from "./NodeCanvasContext";
 export declare class NodeCanvasRenderer implements g.Renderer {
     private context;
     private width;
     private height;
-    constructor(context: CanvasRenderingContext2D, width: number, height: number);
+    constructor(context: NodeCanvasContext, width: number, height: number);
     begin(): void;
     drawSprites(): void;
     clear(): void;

package/lib/runner/v3/platform/graphics/canvas/NodeCanvasRenderer.js

@@ -18,10 +18,10 @@ class NodeCanvasRenderer {
         this.context.clearRect(0, 0, this.width, this.height);
     }
     end() {
-        // do notiong
+        // do nothing
     }
     drawImage(surface, offsetX, offsetY, width, height, canvasOffsetX, canvasOffsetY) {
-        this.context.drawImage(surface._drawable, offsetX, offsetY, width, height, canvasOffsetX, canvasOffsetY, width, height);
+        this.context.drawImage(surface, offsetX, offsetY, width, height, canvasOffsetX, canvasOffsetY, width, height);
     }
     translate(x, y) {
         this.context.translate(x, y);

package/lib/runner/v3/platform/graphics/canvas/NodeCanvasSurface.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeCanvasSurface = void 0;
+const NodeCanvasContext_1 = require("./NodeCanvasContext");
 const NodeCanvasRenderer_1 = require("./NodeCanvasRenderer");
 class NodeCanvasSurface {
     constructor(canvas) {
         this.width = canvas.width;
         this.height = canvas.height;
         this._drawable = canvas;
-        this._renderer = new NodeCanvasRenderer_1.NodeCanvasRenderer(canvas.getContext("2d"), canvas.width, canvas.height);
+        const context = new NodeCanvasContext_1.NodeCanvasContext(canvas.getContext("2d"));
+        this._renderer = new NodeCanvasRenderer_1.NodeCanvasRenderer(context, canvas.width, canvas.height);
     }
     renderer() {
         return this._renderer;

package/lib/runner/v3/platform/graphics/canvas/RenderingState.d.ts

@@ -0,0 +1,8 @@
+import { AffineTransformer } from "./AffineTransformer";
+export declare class RenderingState {
+    fillStyle: string;
+    globalAlpha: number;
+    globalCompositeOperation: string;
+    transformer: AffineTransformer;
+    constructor(crs?: RenderingState);
+}

package/lib/runner/v3/platform/graphics/canvas/RenderingState.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderingState = void 0;
+const AffineTransformer_1 = require("./AffineTransformer");
+class RenderingState {
+    constructor(crs) {
+        if (crs) {
+            this.fillStyle = crs.fillStyle;
+            this.globalAlpha = crs.globalAlpha;
+            this.globalCompositeOperation = crs.globalCompositeOperation;
+            this.transformer = new AffineTransformer_1.AffineTransformer(crs.transformer);
+        }
+        else {
+            this.fillStyle = "#000000";
+            this.globalAlpha = 1.0;
+            this.globalCompositeOperation = "source-over";
+            this.transformer = new AffineTransformer_1.AffineTransformer();
+        }
+    }
+}
+exports.RenderingState = RenderingState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akashic/headless-driver",
-  "version": "2.13.2",
+  "version": "2.13.4",
   "description": "A library to execute contents using Akashic Engine headlessly",
   "main": "lib/index.js",
   "author": "DWANGO Co., Ltd.",
@@ -29,7 +29,7 @@
     "@akashic/trigger": "^2.0.0",
     "engine-files-v1": "npm:@akashic/engine-files@1.4.0",
     "engine-files-v2": "npm:@akashic/engine-files@2.4.0",
-    "engine-files-v3": "npm:@akashic/engine-files@3.7.12",
+    "engine-files-v3": "npm:@akashic/engine-files@3.7.13",
     "js-sha256": "^0.10.0",
     "lodash.clonedeep": "^4.5.0",
     "node-fetch": "^2.6.7"
@@ -44,7 +44,7 @@
     "@types/pixelmatch": "^5.2.4",
     "@types/pngjs": "^6.0.1",
     "@typescript-eslint/eslint-plugin": "^6.12.0",
-    "canvas": "^2.10.1",
+    "canvas": "^2.11.2",
     "eslint": "^8.54.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.29.0",