@akashic/headless-driver 1.11.36 → 2.0.0

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasGlyph = void 0;
+class NodeCanvasGlyph {
+    constructor(code, x, y, width, height, offsetX = 0, offsetY = 0, advanceWidth = width, surface, isSurfaceValid) {
+        this.code = code;
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.offsetX = offsetX;
+        this.offsetY = offsetY;
+        this.advanceWidth = advanceWidth;
+        this.surface = surface;
+        this.isSurfaceValid = isSurfaceValid;
+        this._atlas = null;
+    }
+    renderingWidth(fontSize) {
+        if (!this.width || !this.height) {
+            return 0;
+        }
+        return (fontSize / this.height) * this.width;
+    }
+}
+exports.NodeCanvasGlyph = NodeCanvasGlyph;

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

@@ -0,0 +1,24 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare class NodeCanvasGlyphFactory implements g.GlyphFactory {
+    /**
+     * 実行環境が描画可能な最小フォントサイズ
+     */
+    static _environmentMinimumFontSize: number;
+    fontFamily: string | string[];
+    fontSize: number;
+    baselineHeight: number;
+    fontColor: string;
+    fontWeight: g.FontWeightString;
+    strokeWidth: number;
+    strokeColor: string;
+    strokeOnly: boolean;
+    _glyphAreas: {
+        [key: number]: g.GlyphArea;
+    };
+    _marginW: number;
+    _marginH: number;
+    _cssFontFamily: string;
+    constructor(fontFamily: string | string[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeightString);
+    create(code: number): g.Glyph;
+    measureMinimumFontSize(): number;
+}

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

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasGlyphFactory = void 0;
+const canvas_1 = require("canvas");
+const NodeCanvasGlyph_1 = require("./NodeCanvasGlyph");
+const NodeCanvasSurface_1 = require("./NodeCanvasSurface");
+function createGlyphRenderedSurface(code, fontSize, cssFontFamily, baselineHeight, marginW, marginH, needImageData, fontColor, strokeWidth, strokeColor, strokeOnly, fontWeight) {
+    // 要求されたフォントサイズが描画可能な最小フォントサイズ以下だった場合、必要なスケーリング係数
+    const scale = fontSize < NodeCanvasGlyphFactory._environmentMinimumFontSize ? fontSize / NodeCanvasGlyphFactory._environmentMinimumFontSize : 1;
+    const surfaceWidth = Math.ceil((fontSize + marginW * 2) * scale);
+    const surfaceHeight = Math.ceil((fontSize + marginH * 2) * scale);
+    // NOTE: canvasを直接操作する
+    // 理由:
+    // * Renderer#drawSystemText()を廃止または非推奨にしたいのでそれを用いず文字列を描画する
+    // * RenderingHelperがcontextの状態を復帰するためTextMetricsを取れない
+    const canvas = new canvas_1.Canvas(surfaceWidth, surfaceHeight);
+    const context = canvas.getContext("2d");
+    const str = code & 0xffff0000 ? String.fromCharCode((code & 0xffff0000) >>> 16, code & 0xffff) : String.fromCharCode(code);
+    const fontWeightValue = fontWeight === "bold" ? "bold " : "";
+    context.save();
+    // CanvasRenderingContext2D.font
+    // see: https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/font
+    // > This string uses the same syntax as the CSS font specifier. The default font is 10px sans-serif.
+    context.font = fontWeightValue + fontSize + "px " + cssFontFamily;
+    context.textAlign = "left";
+    context.textBaseline = "alphabetic";
+    context.lineJoin = "bevel";
+    // 描画可能な最小フォントサイズ以下のフォントサイズはスケーリングで実現する
+    if (scale !== 1)
+        context.scale(scale, scale);
+    if (strokeWidth > 0) {
+        context.lineWidth = strokeWidth;
+        context.strokeStyle = strokeColor;
+        context.strokeText(str, marginW, marginH + baselineHeight);
+    }
+    if (!strokeOnly) {
+        context.fillStyle = fontColor;
+        context.fillText(str, marginW, marginH + baselineHeight);
+    }
+    const advanceWidth = context.measureText(str).width;
+    context.restore();
+    const result = {
+        surface: new NodeCanvasSurface_1.NodeCanvasSurface(canvas),
+        advanceWidth: advanceWidth,
+        imageData: needImageData ? context.getImageData(0, 0, canvas.width, canvas.height) : null
+    };
+    return result;
+}
+function calcGlyphArea(imageData) {
+    let sx = imageData.width;
+    let sy = imageData.height;
+    let ex = 0;
+    let ey = 0;
+    let currentPos = 0;
+    for (let y = 0, height = imageData.height; y < height; y = (y + 1) | 0) {
+        for (let x = 0, width = imageData.width; x < width; x = (x + 1) | 0) {
+            const a = imageData.data[currentPos + 3]; // get alpha value
+            if (a !== 0) {
+                if (x < sx) {
+                    sx = x;
+                }
+                if (x > ex) {
+                    ex = x;
+                }
+                if (y < sy) {
+                    sy = y;
+                }
+                if (y > ey) {
+                    ey = y;
+                }
+            }
+            currentPos += 4; // go to next pixel
+        }
+    }
+    let glyphArea;
+    if (sx === imageData.width) {
+        // 空白文字
+        glyphArea = { x: 0, y: 0, width: 0, height: 0 }; // 空の領域に設定
+    }
+    else {
+        // sx, sy, ex, eyは座標ではなく画素のメモリ上の位置を指す添字。
+        // 故にwidth, heightを算出する時 1 加算する。
+        glyphArea = { x: sx, y: sy, width: ex - sx + 1, height: ey - sy + 1 };
+    }
+    return glyphArea;
+}
+function isGlyphAreaEmpty(glyphArea) {
+    return glyphArea.width === 0 || glyphArea.height === 0;
+}
+// ジェネリックフォントファミリとして定義されているキーワードのリスト
+// see: https://developer.mozilla.org/en-US/docs/Web/CSS/font-family
+const genericFontFamilyNames = ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui"];
+// ジェネリックフォントファミリでない時クォートする。
+// > Font family names must either be given quoted as strings, or unquoted as a sequence of one or more identifiers.
+// > Generic family names are keywords and must not be quoted.
+// see: https://developer.mozilla.org/en-US/docs/Web/CSS/font-family
+function quoteIfNotGeneric(name) {
+    if (genericFontFamilyNames.indexOf(name) !== -1) {
+        return name;
+    }
+    else {
+        return `"${name}"`;
+    }
+}
+function fontFamily2CSSFontFamily(fontFamily) {
+    if (typeof fontFamily === "string") {
+        return quoteIfNotGeneric(fontFamily);
+    }
+    else {
+        return fontFamily
+            .map((font) => {
+            if (typeof font === "string") {
+                return quoteIfNotGeneric(font);
+            }
+            else {
+                return font;
+            }
+        })
+            .join(",");
+    }
+}
+class NodeCanvasGlyphFactory {
+    constructor(fontFamily, fontSize, baselineHeight = fontSize, fontColor = "black", strokeWidth = 0, strokeColor = "black", strokeOnly = false, fontWeight = "normal") {
+        this.fontFamily = fontFamily;
+        this.fontSize = fontSize;
+        this.fontWeight = fontWeight;
+        this.baselineHeight = baselineHeight;
+        this.fontColor = fontColor;
+        this.strokeWidth = strokeWidth;
+        this.strokeColor = strokeColor;
+        this.strokeOnly = strokeOnly;
+        this._glyphAreas = {};
+        this._cssFontFamily = fontFamily2CSSFontFamily(fontFamily);
+        // Akashicエンジンは指定されたフォントに利用可能なものが見つからない時
+        // `g.FontFamily.SansSerif` を利用する、と仕様して定められている。
+        const fallbackFontFamilyName = "sans-serif";
+        if (this._cssFontFamily.indexOf(fallbackFontFamilyName) === -1) {
+            this._cssFontFamily += "," + fallbackFontFamilyName;
+        }
+        // `this.fontSize`の大きさの文字を描画するためのサーフェスを生成する。
+        // 一部の文字は縦横が`this.fontSize`幅の矩形に収まらない。
+        // そこで上下左右にマージンを設ける。マージン幅は`this.fontSize`に
+        // 0.3 を乗じたものにする。0.3に確たる根拠はないが、検証した範囲では
+        // これで十分であることを確認している。
+        //
+        // strokeWidthサポートに伴い、輪郭線の厚みを加味している。
+        this._marginW = Math.ceil(this.fontSize * 0.3 + this.strokeWidth / 2);
+        this._marginH = Math.ceil(this.fontSize * 0.3 + this.strokeWidth / 2);
+        if (NodeCanvasGlyphFactory._environmentMinimumFontSize === undefined) {
+            NodeCanvasGlyphFactory._environmentMinimumFontSize = this.measureMinimumFontSize();
+        }
+    }
+    create(code) {
+        var _a, _b;
+        let result = null;
+        let glyphArea = this._glyphAreas[code];
+        if (!glyphArea) {
+            result = createGlyphRenderedSurface(code, this.fontSize, this._cssFontFamily, this.baselineHeight, this._marginW, this._marginH, true, this.fontColor, this.strokeWidth, this.strokeColor, this.strokeOnly, this.fontWeight);
+            glyphArea = calcGlyphArea(result.imageData); // NOTE: `needImageData` が true のため必ず真
+            glyphArea.advanceWidth = result.advanceWidth;
+            this._glyphAreas[code] = glyphArea;
+        }
+        if (isGlyphAreaEmpty(glyphArea)) {
+            if (result) {
+                result.surface.destroy();
+            }
+            return new NodeCanvasGlyph_1.NodeCanvasGlyph(code, 0, 0, 0, 0, 0, 0, glyphArea.advanceWidth, undefined, true);
+        }
+        else {
+            // g.Glyphに格納するサーフェスを生成する。
+            // glyphAreaはサーフェスをキャッシュしないため、描画する内容を持つグリフに対しては
+            // サーフェスを生成する。もし前段でcalcGlyphArea()のためのサーフェスを生成して
+            // いればここでは生成せずにそれを利用する。
+            if (!result) {
+                result = createGlyphRenderedSurface(code, this.fontSize, this._cssFontFamily, this.baselineHeight, this._marginW, this._marginH, false, this.fontColor, this.strokeWidth, this.strokeColor, this.strokeOnly, this.fontWeight);
+            }
+            return new NodeCanvasGlyph_1.NodeCanvasGlyph(code, glyphArea.x, glyphArea.y, (_a = glyphArea.width) !== null && _a !== void 0 ? _a : 0, (_b = glyphArea.height) !== null && _b !== void 0 ? _b : 0, glyphArea.x - this._marginW, glyphArea.y - this._marginH, glyphArea.advanceWidth, result.surface, true);
+        }
+    }
+    // 実行環境の描画可能なフォントサイズの最小値を返す
+    measureMinimumFontSize() {
+        let fontSize = 1;
+        const str = "M";
+        const canvas = new canvas_1.Canvas(50, 50);
+        const context = canvas.getContext("2d");
+        if (context == null) {
+            throw new Error("cannot get canvas context");
+        }
+        context.textAlign = "left";
+        context.textBaseline = "alphabetic";
+        context.lineJoin = "bevel";
+        let preWidth;
+        context.font = fontSize + "px sans-serif";
+        let width = context.measureText(str).width;
+        do {
+            preWidth = width;
+            fontSize += 1;
+            context.font = fontSize + "px sans-serif";
+            width = context.measureText(str).width;
+        } while (preWidth === width || fontSize > 50); // フォントサイズに対応しない動作環境の場合を考慮して上限値を設ける
+        return fontSize;
+    }
+}
+exports.NodeCanvasGlyphFactory = NodeCanvasGlyphFactory;

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

@@ -0,0 +1,16 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+import { Asset } from "../../assets/Asset";
+export declare class NodeCanvasImageAsset extends Asset implements g.ImageAsset {
+    type: "image";
+    width: number;
+    height: number;
+    hint: g.ImageAssetHint | undefined;
+    _surface: g.Surface | null;
+    private data;
+    private dataCache;
+    constructor(id: string, path: string, width: number, height: number);
+    destroy(): void;
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+    initialize(hint: g.ImageAssetHint): void;
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasImageAsset = void 0;
+const canvas_1 = require("canvas");
+const Asset_1 = require("../../assets/Asset");
+const NodeCanvasSurface_1 = require("./NodeCanvasSurface");
+class NodeCanvasImageAsset extends Asset_1.Asset {
+    constructor(id, path, width, height) {
+        super(id, path);
+        this.type = "image";
+        this._surface = null;
+        this.data = null;
+        this.dataCache = null;
+        this.width = width;
+        this.height = height;
+    }
+    destroy() {
+        if (this._surface && !this._surface.destroyed()) {
+            this._surface.destroy();
+        }
+        this.data = null;
+        this._surface = null;
+        super.destroy();
+    }
+    _load(loader) {
+        if (this.dataCache != null) {
+            // restore image asset data and metadata destroyed in this.destroy()
+            this.data = this.dataCache.data;
+            this.id = this.dataCache.id;
+            this.onDestroyed = this.dataCache.onDestroyed;
+            this.originalPath = this.dataCache.originalPath;
+            this.path = this.dataCache.path;
+            this.width = this.dataCache.width;
+            this.height = this.dataCache.height;
+            loader._onAssetLoad(this);
+        }
+        else {
+            const image = new canvas_1.Image();
+            image.onerror = () => {
+                loader._onAssetError(this, {
+                    name: "AssetLoadError",
+                    message: "HTMLImageAsset unknown loading error",
+                    retriable: false
+                });
+            };
+            image.onload = () => {
+                this.data = image;
+                this.dataCache = {
+                    data: image,
+                    id: this.id,
+                    onDestroyed: this.onDestroyed,
+                    originalPath: this.originalPath,
+                    path: this.path,
+                    width: this.width,
+                    height: this.height
+                };
+                loader._onAssetLoad(this);
+            };
+            image.src = this.path;
+        }
+    }
+    asSurface() {
+        if (this.data == null) {
+            throw new Error("NodeCanvasImageAsset#asSurface(): not yet loaded.");
+        }
+        if (this._surface == null) {
+            const canvas = new canvas_1.Canvas(this.width, this.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(this.data, 0, 0, this.width, this.height);
+            this._surface = new NodeCanvasSurface_1.NodeCanvasSurface(canvas);
+        }
+        return this._surface;
+    }
+    initialize(hint) {
+        this.hint = hint;
+    }
+}
+exports.NodeCanvasImageAsset = NodeCanvasImageAsset;

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

@@ -0,0 +1,26 @@
+import type { CanvasRenderingContext2D } from "canvas";
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare class NodeCanvasRenderer implements g.Renderer {
+    private context;
+    private width;
+    private height;
+    constructor(context: CanvasRenderingContext2D, width: number, height: number);
+    begin(): void;
+    drawSprites(): void;
+    clear(): void;
+    end(): void;
+    drawImage(surface: g.Surface, offsetX: number, offsetY: number, width: number, height: number, canvasOffsetX: number, canvasOffsetY: number): void;
+    translate(x: number, y: number): void;
+    transform(matrix: number[]): void;
+    opacity(opacity: number): void;
+    save(): void;
+    restore(): void;
+    fillRect(x: number, y: number, width: number, height: number, cssColor: string): void;
+    setCompositeOperation(operation: g.CompositeOperationString): void;
+    setOpacity(opacity: number): void;
+    setTransform(matrix: number[]): void;
+    setShaderProgram(_shaderProgram: g.ShaderProgram | null): void;
+    isSupportedShaderProgram(): boolean;
+    _getImageData(sx: number, sy: number, sw: number, sh: number): g.ImageData | null;
+    _putImageData(imageData: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasRenderer = void 0;
+const CompositeOperationConverter_1 = require("./CompositeOperationConverter");
+class NodeCanvasRenderer {
+    constructor(context, width, height) {
+        this.context = context;
+        this.width = width;
+        this.height = height;
+    }
+    begin() {
+        // do nothing
+    }
+    drawSprites() {
+        // do nothing
+    }
+    clear() {
+        this.context.clearRect(0, 0, this.width, this.height);
+    }
+    end() {
+        // do notiong
+    }
+    drawImage(surface, offsetX, offsetY, width, height, canvasOffsetX, canvasOffsetY) {
+        this.context.drawImage(surface._drawable, offsetX, offsetY, width, height, canvasOffsetX, canvasOffsetY, width, height);
+    }
+    translate(x, y) {
+        this.context.translate(x, y);
+    }
+    transform(matrix) {
+        // @ts-ignore 高速化のため型チェックを無効
+        this.context.transform.apply(this.context, matrix);
+    }
+    opacity(opacity) {
+        // NOTE: globalAlphaの初期値が1であることは仕様上保証されているため、常に掛け合わせる
+        this.context.globalAlpha *= opacity;
+    }
+    save() {
+        this.context.save();
+    }
+    restore() {
+        this.context.restore();
+    }
+    fillRect(x, y, width, height, cssColor) {
+        const _fillStyle = this.context.fillStyle;
+        this.context.fillStyle = cssColor;
+        this.context.fillRect(x, y, width, height);
+        this.context.fillStyle = _fillStyle;
+    }
+    setCompositeOperation(operation) {
+        this.context.globalCompositeOperation = CompositeOperationConverter_1.CompositeOperationConverter.toContext2D(operation);
+    }
+    setOpacity(opacity) {
+        this.context.globalAlpha = opacity;
+    }
+    setTransform(matrix) {
+        // @ts-ignore 高速化のため型チェックを無効
+        this.context.setTransform.apply(this.context, matrix);
+    }
+    setShaderProgram(_shaderProgram) {
+        // do nothing
+    }
+    isSupportedShaderProgram() {
+        return false;
+    }
+    _getImageData(sx, sy, sw, sh) {
+        return this.context.getImageData(sx, sy, sw, sh);
+    }
+    _putImageData(imageData, dx, dy, dirtyX = 0, dirtyY = 0, dirtyWidth = imageData.width, dirtyHeight = imageData.height) {
+        this.context.putImageData(imageData, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight);
+    }
+}
+exports.NodeCanvasRenderer = NodeCanvasRenderer;

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

@@ -0,0 +1,14 @@
+import type { Canvas } from "canvas";
+import type { akashicEngine as g } from "../../../engineFiles";
+import { NodeCanvasRenderer } from "./NodeCanvasRenderer";
+export declare class NodeCanvasSurface implements g.Surface {
+    width: number;
+    height: number;
+    _drawable: Canvas;
+    _renderer: NodeCanvasRenderer;
+    constructor(canvas: Canvas);
+    renderer(): NodeCanvasRenderer;
+    isPlaying(): boolean;
+    destroy(): void;
+    destroyed(): boolean;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCanvasSurface = void 0;
+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);
+    }
+    renderer() {
+        return this._renderer;
+    }
+    isPlaying() {
+        return false;
+    }
+    destroy() {
+        // do nothing
+    }
+    destroyed() {
+        return this._renderer == null;
+    }
+}
+exports.NodeCanvasSurface = NodeCanvasSurface;

package/lib/runner/v3/platform/graphics/null/NullGlyph.d.ts

@@ -0,0 +1,16 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare class NullGlyph implements g.Glyph {
+    code: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    surface: g.Surface;
+    offsetX: number;
+    offsetY: number;
+    advanceWidth: number;
+    isSurfaceValid: boolean;
+    _atlas: g.SurfaceAtlas | null;
+    constructor(code: number, x: number, y: number, width: number, height: number, offsetX: number | undefined, offsetY: number | undefined, advanceWidth: number | undefined, surface: g.Surface, isSurfaceValid: boolean);
+    renderingWidth(fontSize: number): number;
+}

package/lib/runner/v3/platform/graphics/null/NullGlyph.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullGlyph = void 0;
+class NullGlyph {
+    constructor(code, x, y, width, height, offsetX = 0, offsetY = 0, advanceWidth = width, surface, isSurfaceValid) {
+        this.code = code;
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.offsetX = offsetX;
+        this.offsetY = offsetY;
+        this.advanceWidth = advanceWidth;
+        this.surface = surface;
+        this.isSurfaceValid = isSurfaceValid;
+        this._atlas = null;
+    }
+    renderingWidth(fontSize) {
+        if (!this.width || !this.height) {
+            return 0;
+        }
+        return (fontSize / this.height) * this.width;
+    }
+}
+exports.NullGlyph = NullGlyph;

package/lib/runner/v3/platform/graphics/null/NullGlyphFactory.d.ts

@@ -0,0 +1,14 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare class NullGlyphFactory implements g.GlyphFactory {
+    fontFamily: string | string[];
+    fontSize: number;
+    baselineHeight: number;
+    fontColor: string;
+    fontWeight: g.FontWeightString;
+    strokeWidth: number;
+    strokeColor: string;
+    strokeOnly: boolean;
+    private dummySurface;
+    constructor(fontFamily: string | string[], fontSize: number, baselineHeight?: number, fontColor?: string, strokeWidth?: number, strokeColor?: string, strokeOnly?: boolean, fontWeight?: g.FontWeightString);
+    create(code: number): g.Glyph;
+}

package/lib/runner/v3/platform/graphics/null/NullGlyphFactory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullGlyphFactory = void 0;
+const NullGlyph_1 = require("./NullGlyph");
+const NullSurface_1 = require("./NullSurface");
+class NullGlyphFactory {
+    constructor(fontFamily, fontSize, baselineHeight = fontSize, fontColor = "black", strokeWidth = 0, strokeColor = "black", strokeOnly = false, fontWeight = "normal") {
+        this.dummySurface = new NullSurface_1.NullSurface(0, 0);
+        this.fontFamily = fontFamily;
+        this.fontSize = fontSize;
+        this.fontWeight = fontWeight;
+        this.baselineHeight = baselineHeight;
+        this.fontColor = fontColor;
+        this.strokeWidth = strokeWidth;
+        this.strokeColor = strokeColor;
+        this.strokeOnly = strokeOnly;
+    }
+    create(code) {
+        return new NullGlyph_1.NullGlyph(code, 0, 0, 0, 0, 0, 0, this.fontSize, this.dummySurface, true);
+    }
+}
+exports.NullGlyphFactory = NullGlyphFactory;

package/lib/runner/v3/platform/graphics/null/NullImageAsset.d.ts

@@ -0,0 +1,13 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+import { Asset } from "../../assets/Asset";
+export declare class NullImageAsset extends Asset implements g.ImageAsset {
+    type: "image";
+    width: number;
+    height: number;
+    hint: g.ImageAssetHint | undefined;
+    _surface: g.Surface | null;
+    constructor(id: string, assetPath: string, width: number, height: number);
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+    initialize(hint: g.ImageAssetHint): void;
+}

package/lib/runner/v3/platform/graphics/null/NullImageAsset.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullImageAsset = void 0;
+const Asset_1 = require("../../assets/Asset");
+const NullSurface_1 = require("./NullSurface");
+class NullImageAsset extends Asset_1.Asset {
+    constructor(id, assetPath, width, height) {
+        super(id, assetPath);
+        this.type = "image";
+        this._surface = null;
+        this.width = width;
+        this.height = height;
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    asSurface() {
+        return this._surface || (this._surface = new NullSurface_1.NullSurface(this.width, this.height));
+    }
+    initialize(hint) {
+        this.hint = hint;
+    }
+}
+exports.NullImageAsset = NullImageAsset;

package/lib/runner/v3/platform/graphics/null/NullRenderer.d.ts

@@ -0,0 +1,21 @@
+import type { akashicEngine as g } from "../../../engineFiles";
+export declare class NullRenderer implements g.Renderer {
+    begin(): void;
+    end(): void;
+    clear(): void;
+    drawImage(_surface: g.Surface, _offsetX: number, _offsetY: number, _width: number, _height: number, _destOffsetX: number, _destOffsetY: number): void;
+    drawSprites(_surface: g.Surface, _offsetX: number[], _offsetY: number[], _width: number[], _height: number[], _canvasOffsetX: number[], _canvasOffsetY: number[], _count: number): void;
+    translate(_x: number, _y: number): void;
+    transform(_matrix: number[]): void;
+    opacity(_opacity: number): void;
+    save(): void;
+    restore(): void;
+    fillRect(_x: number, _y: number, _width: number, _height: number, _cssColor: string): void;
+    setCompositeOperation(_operation: g.CompositeOperationString): void;
+    setTransform(_matrix: number[]): void;
+    setOpacity(_opacity: number): void;
+    isSupportedShaderProgram(): boolean;
+    setShaderProgram(_shaderProgram: g.ShaderProgram | null): void;
+    _getImageData(_sx: number, _sy: number, _sw: number, _sh: number): g.ImageData | null;
+    _putImageData(_imageData: g.ImageData, _dx: number, _dy: number, _dirtyX?: number, _dirtyY?: number, _dirtyWidth?: number, _dirtyHeight?: number): void;
+}