@akashic/headless-driver 1.11.36 → 2.0.0

package/lib/runner/v1/platform/assets/NodeScriptAsset.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeScriptAsset = void 0;
+const aev1_1 = require("aev1");
+class NodeScriptAsset extends aev1_1.akashicEngine.ScriptAsset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.errorHandler = param.errorHandler;
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            // NOTE: 過去バージョンのため型については精査しない
+            if (err) {
+                loader._onAssetError(this, err);
+            }
+            else {
+                this.script = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+    execute(execEnv) {
+        const func = new Function("g", NodeScriptAsset.PRE_SCRIPT + this.script + NodeScriptAsset.POST_SCRIPT);
+        try {
+            func(execEnv);
+        }
+        catch (e) {
+            this.errorHandler(e);
+        }
+        return execEnv.module.exports;
+    }
+}
+exports.NodeScriptAsset = NodeScriptAsset;
+NodeScriptAsset.PRE_SCRIPT = "(function(exports, require, module, __filename, __dirname) {\n";
+NodeScriptAsset.POST_SCRIPT = "\n})(g.module.exports, g.module.require, g.module, g.filename, g.dirname);";

package/lib/runner/v1/platform/assets/NodeTextAsset.d.ts

@@ -0,0 +1,11 @@
+import { akashicEngine as g } from "aev1";
+export interface NodeTextAssetParameters {
+    id: string;
+    path: string;
+    loadFileHandler: (url: string, callback: (err: Error | null, data?: string) => void) => void;
+}
+export declare class NodeTextAsset extends g.TextAsset {
+    private loadFileHandler;
+    constructor(param: NodeTextAssetParameters);
+    _load(loader: g.AssetLoadHandler): void;
+}

package/lib/runner/v1/platform/assets/NodeTextAsset.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTextAsset = void 0;
+const aev1_1 = require("aev1");
+class NodeTextAsset extends aev1_1.akashicEngine.TextAsset {
+    constructor(param) {
+        super(param.id, param.path);
+        this.loadFileHandler = param.loadFileHandler;
+    }
+    _load(loader) {
+        this.loadFileHandler(this.path, (err, text) => {
+            // NOTE: 過去バージョンのため型については精査しない
+            if (err) {
+                loader._onAssetError(this, err);
+            }
+            else {
+                this.data = text;
+                loader._onAssetLoad(this);
+            }
+        });
+    }
+}
+exports.NodeTextAsset = NodeTextAsset;

package/lib/runner/v1/platform/assets/NullAudioAsset.d.ts

@@ -0,0 +1,4 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullAudioAsset extends g.AudioAsset {
+    _load(loader: g.AssetLoadHandler): void;
+}

package/lib/runner/v1/platform/assets/NullAudioAsset.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioAsset = void 0;
+const aev1_1 = require("aev1");
+class NullAudioAsset extends aev1_1.akashicEngine.AudioAsset {
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+}
+exports.NullAudioAsset = NullAudioAsset;

package/lib/runner/v1/platform/assets/NullImageAsset.d.ts

@@ -0,0 +1,6 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullImageAsset extends g.ImageAsset {
+    _surface: g.Surface | null;
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+}

package/lib/runner/v1/platform/assets/NullImageAsset.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullImageAsset = void 0;
+const aev1_1 = require("aev1");
+const NullSurface_1 = require("../NullSurface");
+class NullImageAsset extends aev1_1.akashicEngine.ImageAsset {
+    constructor() {
+        super(...arguments);
+        this._surface = null;
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    asSurface() {
+        return this._surface || (this._surface = new NullSurface_1.NullSurface(this.width, this.height, null));
+    }
+}
+exports.NullImageAsset = NullImageAsset;

package/lib/runner/v1/platform/assets/NullVideoAsset.d.ts

@@ -0,0 +1,10 @@
+import { akashicEngine as g } from "aev1";
+export declare class NullVideoAsset extends g.VideoAsset {
+    _surface: g.Surface | null;
+    _player: g.VideoPlayer;
+    constructor(id: string, assetPath: string, width: number, height: number, system: any, loop: boolean, useRealSize: boolean);
+    _load(loader: g.AssetLoadHandler): void;
+    asSurface(): g.Surface;
+    getPlayer(): g.VideoPlayer;
+    play(): g.VideoPlayer;
+}

package/lib/runner/v1/platform/assets/NullVideoAsset.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullVideoAsset = void 0;
+const aev1_1 = require("aev1");
+const NullSurface_1 = require("../NullSurface");
+class NullVideoAsset extends aev1_1.akashicEngine.VideoAsset {
+    constructor(id, assetPath, width, height, system, loop, useRealSize) {
+        super(id, assetPath, width, height, system, loop, useRealSize);
+        this._surface = null;
+        this._player = new aev1_1.akashicEngine.VideoPlayer();
+    }
+    _load(loader) {
+        loader._onAssetLoad(this);
+    }
+    asSurface() {
+        return this._surface || (this._surface = new NullSurface_1.NullSurface(this.width, this.height, null));
+    }
+    getPlayer() {
+        return this._player;
+    }
+    play() {
+        return this._player;
+    }
+}
+exports.NullVideoAsset = NullVideoAsset;

package/lib/runner/v2/RunnerV2.d.ts

@@ -0,0 +1,26 @@
+import { akashicEngine as g, gameDriver as gdr } from "aev2";
+import type { RunnerStartParameters } from "../Runner";
+import { Runner } from "../Runner";
+import type { RunnerPointEvent } from "../types";
+import { PlatformV2 } from "./platform/PlatformV2";
+export declare type RunnerV2Game = g.Game;
+export declare class RunnerV2 extends Runner {
+    readonly engineVersion: string;
+    readonly g: typeof g;
+    platform: PlatformV2 | null;
+    private driver;
+    private fps;
+    private running;
+    start(params?: RunnerStartParameters): Promise<RunnerV2Game | null>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    step(): void;
+    advance(ms: number): Promise<void>;
+    changeGameDriverState(param: gdr.GameDriverInitializeParameterObject): Promise<void>;
+    firePointEvent(event: RunnerPointEvent): void;
+    getPrimarySurface(): never;
+    protected _stepMinimal(): void;
+    private initGameDriver;
+    private onSendedToExternal;
+}

package/lib/runner/v2/RunnerV2.js

@@ -0,0 +1,229 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerV2 = void 0;
+const aev2_1 = require("aev2");
+const Runner_1 = require("../Runner");
+const PlatformV2_1 = require("./platform/PlatformV2");
+class RunnerV2 extends Runner_1.Runner {
+    constructor() {
+        super(...arguments);
+        this.engineVersion = "2";
+        this.g = aev2_1.akashicEngine;
+        this.platform = null;
+        this.driver = null;
+        this.fps = null;
+        this.running = false;
+    }
+    start(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let game = null;
+            const paused = !!(params === null || params === void 0 ? void 0 : params.paused);
+            try {
+                game = yield this.initGameDriver();
+                if (!paused) {
+                    this.resume();
+                }
+            }
+            catch (e) {
+                this.onError(e);
+            }
+            return game;
+        });
+    }
+    stop() {
+        if (this.driver) {
+            this.driver.stopGame();
+            this.driver = null;
+        }
+        this.running = false;
+    }
+    pause() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#pause() before initialized"));
+            return;
+        }
+        this.platform.pauseLoopers();
+        this.running = false;
+    }
+    resume() {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#resume() before initialized"));
+            return;
+        }
+        this.platform.resumeLoopers();
+        this.running = true;
+    }
+    step() {
+        if (this.fps == null || this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() before initialized"));
+            return;
+        }
+        if (this.running) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#step() in running"));
+            return;
+        }
+        this.platform.advanceLoopers(Math.ceil(1000 / this.fps));
+    }
+    advance(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fps == null || this.platform == null || this.driver == null) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() before initialized"));
+                return;
+            }
+            if (this.running) {
+                this.errorTrigger.fire(new Error("Cannot call Runner#advance() in running"));
+                return;
+            }
+            const { loopMode, skipThreshold } = this.driver.getLoopConfiguration();
+            // NOTE: skip の通知タイミングを一度に制限するため skipThreshold を一時的に変更する。
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold: Math.ceil(ms / this.fps) + 1
+                }
+            });
+            const delta = Math.ceil(1000 / this.fps);
+            let progress = 0;
+            while (progress <= ms) {
+                // NOTE: game-driver の内部実装により Looper 経由で一度に進める時間に制限がある。
+                // そのため一度に進める時間を fps に応じて分割する。
+                this.platform.advanceLoopers(delta);
+                progress += delta;
+            }
+            yield this.changeGameDriverState({
+                loopConfiguration: {
+                    loopMode,
+                    skipThreshold
+                }
+            });
+        });
+    }
+    changeGameDriverState(param) {
+        return new Promise((resolve, reject) => {
+            if (!this.driver) {
+                reject(new Error("Game is not started"));
+                return;
+            }
+            this.driver.changeState(param, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    firePointEvent(event) {
+        if (this.platform == null) {
+            this.errorTrigger.fire(new Error("Cannot call Runner#firePointEvent() before initialized"));
+            return;
+        }
+        let type;
+        if (event.type === "down") {
+            type = 0 /* Down */;
+        }
+        else if (event.type === "move") {
+            type = 1 /* Move */;
+        }
+        else if (event.type === "up") {
+            type = 2 /* Up */;
+        }
+        else {
+            this.errorTrigger.fire(new Error(`RunnerV2#firePointEvent(): unknown event type: ${event.type}`));
+            return;
+        }
+        this.platform.firePointEvent({
+            type,
+            identifier: event.identifier,
+            offset: event.offset
+        });
+    }
+    getPrimarySurface() {
+        throw new Error("RunnerV2#getPrimarySurface(): Not supported");
+    }
+    _stepMinimal() {
+        if (this.fps == null || this.platform == null) {
+            this.errorTrigger.fire(new Error("RunnerV2#_stepHalf(): Cannot call Runner#step() before initialized"));
+            return;
+        }
+        if (this.running) {
+            this.errorTrigger.fire(new Error("RunnerV2#_stepHalf(): Cannot call Runner#step() in running"));
+            return;
+        }
+        // NOTE: 現状 PDI の API 仕様により this.step() では厳密なフレーム更新ができない。そこで、一フレームの 1/2 の時間で進行することでフレームが飛んでしまうことを防止する。
+        this.platform.advanceLoopers(1000 / this.fps / 2);
+    }
+    initGameDriver() {
+        return new Promise((resolve, reject) => {
+            if (this.driver) {
+                this.driver.destroy();
+                this.driver = null;
+            }
+            const player = {
+                id: this.player ? this.player.id : undefined,
+                name: this.player ? this.player.name : undefined
+            };
+            const executionMode = this.executionMode === "active" ? aev2_1.gameDriver.ExecutionMode.Active : aev2_1.gameDriver.ExecutionMode.Passive;
+            this.platform = new PlatformV2_1.PlatformV2({
+                configurationBaseUrl: this.configurationBaseUrl,
+                assetBaseUrl: this.assetBaseUrl,
+                amflow: this.amflow,
+                trusted: this.trusted,
+                renderingMode: this.renderingMode,
+                sendToExternalHandler: (data) => this.onSendedToExternal(data),
+                errorHandler: (e) => this.onError(e),
+                loadFileHandler: (url, callback) => this.loadFileHandler(url, callback)
+            });
+            this.pause();
+            const driver = new aev2_1.gameDriver.GameDriver({
+                platform: this.platform,
+                player,
+                errorHandler: (e) => this.onError(e)
+            });
+            this.driver = driver;
+            let result = null;
+            // TODO: パラメータを外部から変更可能にする
+            driver.initialize({
+                configurationUrl: this.configurationUrl,
+                configurationBase: this.configurationBaseUrl,
+                assetBase: this.assetBaseUrl,
+                driverConfiguration: {
+                    playId: this.playId,
+                    playToken: this.playToken,
+                    executionMode
+                },
+                loopConfiguration: {
+                    loopMode: aev2_1.gameDriver.LoopMode.Realtime
+                },
+                gameArgs: this.gameArgs
+            }, (e) => {
+                if (e) {
+                    reject(e);
+                    return;
+                }
+                if (!result) {
+                    // GameDriver の内部実装上ここに来ることはないはずだが念のため確認
+                    return reject(new Error("Game is null."));
+                }
+                driver.startGame();
+                resolve(result);
+            });
+            driver.gameCreatedTrigger.addOnce((game) => {
+                if (this.externalValue) {
+                    Object.keys(this.externalValue).forEach((key) => {
+                        game.external[key] = this.externalValue[key];
+                    });
+                }
+                this.fps = game.fps;
+                result = game;
+            });
+        });
+    }
+    onSendedToExternal(data) {
+        this.sendToExternalTrigger.fire(data);
+    }
+}
+exports.RunnerV2 = RunnerV2;

package/lib/runner/v2/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RunnerV2";
+export * from "./platform/PlatformV2";
+export { akashicEngine as RunnerV2_g, gameDriver as RunnerV2_gdr, pdi as RunnerV2_pdi } from "aev2";

package/lib/runner/v2/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerV2_pdi = exports.RunnerV2_gdr = exports.RunnerV2_g = void 0;
+__exportStar(require("./RunnerV2"), exports);
+__exportStar(require("./platform/PlatformV2"), exports);
+var aev2_1 = require("aev2");
+Object.defineProperty(exports, "RunnerV2_g", { enumerable: true, get: function () { return aev2_1.akashicEngine; } });
+Object.defineProperty(exports, "RunnerV2_gdr", { enumerable: true, get: function () { return aev2_1.gameDriver; } });
+Object.defineProperty(exports, "RunnerV2_pdi", { enumerable: true, get: function () { return aev2_1.pdi; } });

package/lib/runner/v2/platform/NullAudioPlayer.d.ts

@@ -0,0 +1,3 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullAudioPlayer extends g.AudioPlayer {
+}

package/lib/runner/v2/platform/NullAudioPlayer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullAudioPlayer = void 0;
+const aev2_1 = require("aev2");
+class NullAudioPlayer extends aev2_1.akashicEngine.AudioPlayer {
+}
+exports.NullAudioPlayer = NullAudioPlayer;

package/lib/runner/v2/platform/NullGlyphFactory.d.ts

@@ -0,0 +1,6 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullGlyphFactory extends g.GlyphFactory {
+    private dummySurface;
+    create(code: number): g.Glyph;
+    measureMinimumFontSize(): number;
+}

package/lib/runner/v2/platform/NullGlyphFactory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullGlyphFactory = void 0;
+const aev2_1 = require("aev2");
+const NullSurface_1 = require("./NullSurface");
+class NullGlyphFactory extends aev2_1.akashicEngine.GlyphFactory {
+    constructor() {
+        super(...arguments);
+        this.dummySurface = new NullSurface_1.NullSurface(0, 0);
+    }
+    create(code) {
+        return new aev2_1.akashicEngine.Glyph(code, 0, 0, 0, 0, 0, 0, this.fontSize, this.dummySurface, true);
+    }
+    measureMinimumFontSize() {
+        return 1;
+    }
+}
+exports.NullGlyphFactory = NullGlyphFactory;

package/lib/runner/v2/platform/NullRenderer.d.ts

@@ -0,0 +1,20 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullRenderer extends g.Renderer {
+    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;
+    drawSystemText(_text: string, _x: number, _y: number, _maxWidth: number, _fontSize: number, _textAlign: g.TextAlign, _textBaseline: g.TextBaseline, _textColor: string, _fontFamily: g.FontFamily, _strokeWidth: number, _strokeColor: string, _strokeOnly: boolean): 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.CompositeOperation): 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;
+    _putImageData(_imageData: g.ImageData, _dx: number, _dy: number, _dirtyX?: number, _dirtyY?: number, _dirtyWidth?: number, _dirtyHeight?: number): void;
+}

package/lib/runner/v2/platform/NullRenderer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullRenderer = void 0;
+const aev2_1 = require("aev2");
+class NullRenderer extends aev2_1.akashicEngine.Renderer {
+    clear() {
+        //
+    }
+    drawImage(_surface, _offsetX, _offsetY, _width, _height, _destOffsetX, _destOffsetY) {
+        //
+    }
+    drawSprites(_surface, _offsetX, _offsetY, _width, _height, _canvasOffsetX, _canvasOffsetY, _count) {
+        //
+    }
+    drawSystemText(_text, _x, _y, _maxWidth, _fontSize, _textAlign, _textBaseline, _textColor, _fontFamily, _strokeWidth, _strokeColor, _strokeOnly) {
+        //
+    }
+    translate(_x, _y) {
+        //
+    }
+    transform(_matrix) {
+        //
+    }
+    opacity(_opacity) {
+        //
+    }
+    save() {
+        //
+    }
+    restore() {
+        //
+    }
+    fillRect(_x, _y, _width, _height, _cssColor) {
+        //
+    }
+    setCompositeOperation(_operation) {
+        //
+    }
+    setTransform(_matrix) {
+        //
+    }
+    setOpacity(_opacity) {
+        //
+    }
+    isSupportedShaderProgram() {
+        return false;
+    }
+    setShaderProgram(_shaderProgram) {
+        //
+    }
+    _getImageData(_sx, _sy, _sw, _sh) {
+        return null; // TODO: pdi-types 側の型を修正
+    }
+    _putImageData(_imageData, _dx, _dy, _dirtyX, _dirtyY, _dirtyWidth, _dirtyHeight) {
+        //
+    }
+}
+exports.NullRenderer = NullRenderer;

package/lib/runner/v2/platform/NullSurface.d.ts

@@ -0,0 +1,7 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullSurface extends g.Surface {
+    private _renderer;
+    constructor(width: number, height: number, drawable?: any, isDynamic?: boolean);
+    renderer(): g.Renderer;
+    isPlaying(): boolean;
+}

package/lib/runner/v2/platform/NullSurface.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullSurface = void 0;
+const aev2_1 = require("aev2");
+const NullRenderer_1 = require("./NullRenderer");
+class NullSurface extends aev2_1.akashicEngine.Surface {
+    constructor(width, height, drawable, isDynamic) {
+        super(width, height, drawable, isDynamic);
+        this._renderer = new NullRenderer_1.NullRenderer();
+    }
+    renderer() {
+        return this._renderer;
+    }
+    isPlaying() {
+        return false;
+    }
+}
+exports.NullSurface = NullSurface;

package/lib/runner/v2/platform/NullVideoPlayer.d.ts

@@ -0,0 +1,4 @@
+import { akashicEngine as g } from "aev2";
+export declare class NullVideoplayerAsset extends g.VideoPlayer {
+    isDummy(): boolean;
+}

package/lib/runner/v2/platform/NullVideoPlayer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullVideoplayerAsset = void 0;
+const aev2_1 = require("aev2");
+class NullVideoplayerAsset extends aev2_1.akashicEngine.VideoPlayer {
+    isDummy() {
+        return true;
+    }
+}
+exports.NullVideoplayerAsset = NullVideoplayerAsset;

package/lib/runner/v2/platform/PlatformV2.d.ts

@@ -0,0 +1,23 @@
+import type { akashicEngine as g, pdi } from "aev2";
+import { Looper } from "../../../Looper";
+import type { PlatformParameters } from "../../Platform";
+import { Platform } from "../../Platform";
+export declare class PlatformV2 extends Platform implements pdi.Platform {
+    private resFac;
+    private rendererReq;
+    private primarySurface;
+    private eventHandler;
+    private loopers;
+    private isLooperPaused;
+    constructor(param: PlatformParameters);
+    getResourceFactory(): g.ResourceFactory;
+    setRendererRequirement(requirement: pdi.RendererRequirement): void;
+    setPlatformEventHandler(handler: pdi.PlatformEventHandler): void;
+    getPlatformHandler(): pdi.PlatformEventHandler | null;
+    getPrimarySurface(): g.Surface;
+    createLooper(fun: (deltaTime: number) => number): Looper;
+    advanceLoopers(ms: number): void;
+    pauseLoopers(): void;
+    resumeLoopers(): void;
+    firePointEvent(event: pdi.PointEvent): void;
+}