@next2d/player 1.14.7 → 1.14.9

package/dist/player/util/CacheStore.d.ts

@@ -0,0 +1,115 @@
+import type { CanvasToWebGLContext } from "../../webgl/CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class CacheStore {
+    private readonly _$pool;
+    private readonly _$store;
+    private readonly _$timerMap;
+    private _$context;
+    /**
+     * @constructor
+     */
+    constructor();
+    /**
+     * @member {CanvasToWebGLContext}
+     * @param  {CanvasToWebGLContext} context
+     * @public
+     */
+    set context(context: CanvasToWebGLContext);
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    reset(): void;
+    /**
+     * @param  {CanvasRenderingContext2D|WebGLTexture} object
+     * @return {void}
+     * @method
+     * @public
+     */
+    destroy(object?: CanvasRenderingContext2D | WebGLTexture | null): void;
+    /**
+     * @return {HTMLCanvasElement}
+     * @method
+     * @public
+     */
+    getCanvas(): HTMLCanvasElement;
+    /**
+     * @param   {string} id
+     * @param   {string} type
+     * @returns {void}
+     * @method
+     * @public
+     */
+    remove(id: string, type: string): void;
+    /**
+     * @param  {string|number} id
+     * @return {void}
+     * @method
+     * @public
+     */
+    stopTimer(id: string | number): void;
+    /**
+     * @param   {string|number} id
+     * @returns {void}
+     * @method
+     * @public
+     */
+    removeCache(id: string | number): void;
+    /**
+     * @description 5秒後にキャッシュを削除
+     *
+     * @param  {number|string} id
+     * @return {void}
+     * @method
+     * @public
+     */
+    setRemoveTimer(id: string | number): void;
+    /**
+     * @param  {array} keys
+     * @return {*}
+     * @method
+     * @public
+     */
+    get(keys: any[]): any;
+    /**
+     * @param  {array} keys
+     * @param  {*} value
+     * @return {void}
+     * @method
+     * @public
+     */
+    set(keys: any[], value?: any): void;
+    /**
+     * @param  {array} keys
+     * @return {boolean}
+     * @method
+     * @public
+     */
+    has(keys: any[]): boolean;
+    /**
+     * @param  {*} unique_key
+     * @param  {array}         [matrix=null]
+     * @param  {Float32Array}  [color=null]
+     * @return {array}
+     * @method
+     * @public
+     */
+    generateKeys(unique_key: any, matrix?: number[] | null, color?: Float32Array | null): string[];
+    /**
+     * @param  {Float32Array} color
+     * @return {string}
+     * @method
+     * @public
+     */
+    colorToString(color: Float32Array): string;
+    /**
+     * @param  {string} str
+     * @return {string}
+     * @method
+     * @public
+     */
+    generateHash(str: string): string;
+}

package/dist/player/util/CacheStore.js

@@ -0,0 +1,280 @@
+import { $requestAnimationFrame, $clearTimeout, $setTimeout, $getMap, $poolMap, $getArray } from "./RenderUtil";
+/**
+ * @class
+ */
+export class CacheStore {
+    _$pool;
+    _$store;
+    _$timerMap;
+    _$context;
+    /**
+     * @constructor
+     */
+    constructor() {
+        /**
+         * @type {array}
+         * @private
+         */
+        this._$pool = [];
+        /**
+         * @type {Map}
+         * @private
+         */
+        this._$store = new Map();
+        /**
+         * @type {Map}
+         * @private
+         */
+        this._$timerMap = new Map();
+        /**
+         * @type {CanvasToWebGLContext}
+         * @private
+         */
+        this._$context = null;
+    }
+    /**
+     * @member {CanvasToWebGLContext}
+     * @param  {CanvasToWebGLContext} context
+     * @public
+     */
+    set context(context) {
+        this._$context = context;
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    reset() {
+        for (const data of this._$store.values()) {
+            for (const value of data.values()) {
+                this.destroy(value);
+            }
+            $poolMap(data);
+        }
+        this._$store.clear();
+    }
+    /**
+     * @param  {CanvasRenderingContext2D|WebGLTexture} object
+     * @return {void}
+     * @method
+     * @public
+     */
+    destroy(object = null) {
+        if (!object) {
+            return;
+        }
+        if (object instanceof WebGLTexture) {
+            $requestAnimationFrame(() => {
+                if (!this._$context) {
+                    return;
+                }
+                this
+                    ._$context
+                    .frameBuffer
+                    .releaseTexture(object);
+            });
+            return;
+        }
+        if (object instanceof CanvasRenderingContext2D) {
+            const canvas = object.canvas;
+            const width = canvas.width;
+            const height = canvas.height;
+            object.clearRect(0, 0, width + 1, height + 1);
+            // canvas reset
+            canvas.width = canvas.height = 1;
+            // pool
+            this._$pool.push(canvas);
+        }
+    }
+    /**
+     * @return {HTMLCanvasElement}
+     * @method
+     * @public
+     */
+    getCanvas() {
+        return this._$pool.pop() || document.createElement("canvas");
+    }
+    /**
+     * @param   {string} id
+     * @param   {string} type
+     * @returns {void}
+     * @method
+     * @public
+     */
+    remove(id, type) {
+        if (!this._$store.has(id)) {
+            return;
+        }
+        const data = this._$store.get(id);
+        if (!data.has(type)) {
+            return;
+        }
+        // delete key
+        data.delete(type);
+        if (!data.size) {
+            $poolMap(data);
+            this._$store.delete(id);
+        }
+    }
+    /**
+     * @param  {string|number} id
+     * @return {void}
+     * @method
+     * @public
+     */
+    stopTimer(id) {
+        id = `${id}`;
+        if (this._$timerMap.has(id)) {
+            $clearTimeout(this._$timerMap.get(id));
+            this._$timerMap.delete(id);
+        }
+    }
+    /**
+     * @param   {string|number} id
+     * @returns {void}
+     * @method
+     * @public
+     */
+    removeCache(id) {
+        id = `${id}`;
+        if (this._$store.has(id)) {
+            const data = this._$store.get(id);
+            for (const value of data.values()) {
+                this.destroy(value);
+            }
+            data.clear();
+            $poolMap(data);
+            this._$store.delete(id);
+        }
+        this._$timerMap.delete(id);
+    }
+    /**
+     * @description 5秒後にキャッシュを削除
+     *
+     * @param  {number|string} id
+     * @return {void}
+     * @method
+     * @public
+     */
+    setRemoveTimer(id) {
+        id = `${id}`;
+        this.stopTimer(id);
+        // set timer
+        if (this._$store.has(id)) {
+            // @ts-ignore
+            const timerId = $setTimeout(() => {
+                this.removeCache(id);
+            }, 5000);
+            this._$timerMap.set(id, timerId);
+        }
+    }
+    /**
+     * @param  {array} keys
+     * @return {*}
+     * @method
+     * @public
+     */
+    get(keys) {
+        const id = `${keys[0]}`;
+        const type = `${keys[1]}`;
+        if (this._$store.has(id)) {
+            this.stopTimer(id);
+            const data = this._$store.get(id);
+            if (data.has(type)) {
+                return data.get(type);
+            }
+        }
+        return null;
+    }
+    /**
+     * @param  {array} keys
+     * @param  {*} value
+     * @return {void}
+     * @method
+     * @public
+     */
+    set(keys, value = null) {
+        const id = `${keys[0]}`;
+        const type = `${keys[1]}`;
+        // init
+        if (!this._$store.has(id)) {
+            this._$store.set(id, $getMap());
+        }
+        const data = this._$store.get(id);
+        if (!value) {
+            data.delete(type);
+            if (!data.size) {
+                $poolMap(data);
+                this._$store.delete(id);
+            }
+            return;
+        }
+        const oldValue = data.get(type);
+        if (oldValue && oldValue !== value) {
+            this.destroy(oldValue);
+        }
+        // set cache
+        data.set(type, value);
+    }
+    /**
+     * @param  {array} keys
+     * @return {boolean}
+     * @method
+     * @public
+     */
+    has(keys) {
+        const id = `${keys[0]}`;
+        if (!this._$store.has(id)) {
+            return false;
+        }
+        return this._$store.get(id).has(`${keys[1]}`);
+    }
+    /**
+     * @param  {*} unique_key
+     * @param  {array}         [matrix=null]
+     * @param  {Float32Array}  [color=null]
+     * @return {array}
+     * @method
+     * @public
+     */
+    generateKeys(unique_key, matrix = null, color = null) {
+        let str = "";
+        if (matrix) {
+            str += `${matrix.join("_")}`;
+        }
+        // color
+        if (color) {
+            str += this.colorToString(color);
+        }
+        const keys = $getArray();
+        keys[1] = str ? this.generateHash(str) : "_0";
+        keys[0] = `${unique_key}`;
+        return keys;
+    }
+    /**
+     * @param  {Float32Array} color
+     * @return {string}
+     * @method
+     * @public
+     */
+    colorToString(color) {
+        return color[7] === 0 ? "" : `_${color[7]}`;
+    }
+    /**
+     * @param  {string} str
+     * @return {string}
+     * @method
+     * @public
+     */
+    generateHash(str) {
+        let hash = 0;
+        const length = str.length;
+        for (let idx = 0; idx < length; idx++) {
+            const chr = str.charCodeAt(idx);
+            hash = (hash << 5) - hash + chr;
+            hash |= 0;
+        }
+        return `_${hash}`;
+    }
+}

package/dist/player/util/Global.d.ts

@@ -0,0 +1,23 @@
+import type { LoaderInfo } from "../next2d/display/LoaderInfo";
+/**
+ * @return {number}
+ * @method
+ * @public
+ */
+export declare const $getInstanceId: () => number;
+/**
+ * @return {number}
+ * @method
+ * @public
+ */
+export declare const $getLoaderInfoId: () => number;
+export declare const $getCurrentLoaderInfo: () => LoaderInfo | null;
+export declare const $setCurrentLoaderInfo: (loader_info?: LoaderInfo | null) => void;
+export declare const $getEventType: () => string;
+export declare const $setEventType: (event_type: string) => void;
+export declare const $getEvent: () => MouseEvent | TouchEvent | Event | null;
+export declare const $setEvent: (event?: MouseEvent | TouchEvent | Event | null) => void;
+export declare const $isUpdated: () => boolean;
+export declare const $doUpdated: (update?: boolean) => void;
+export declare const $getSoundMixerVolume: () => number;
+export declare const $setSoundMixerVolume: (volume: number) => void;

package/dist/player/util/Global.js

@@ -0,0 +1,67 @@
+/**
+ * @type {number}
+ */
+let instanceId = 0;
+/**
+ * @return {number}
+ * @method
+ * @public
+ */
+export const $getInstanceId = () => {
+    return instanceId++;
+};
+/**
+ * @type {number}
+ */
+let loaderInfoId = 0;
+/**
+ * @return {number}
+ * @method
+ * @public
+ */
+export const $getLoaderInfoId = () => {
+    return loaderInfoId++;
+};
+/**
+ * @type {LoaderInfo | null}
+ * @public
+ */
+let $currentLoaderInfo = null;
+export const $getCurrentLoaderInfo = () => {
+    return $currentLoaderInfo;
+};
+export const $setCurrentLoaderInfo = (loader_info = null) => {
+    $currentLoaderInfo = loader_info;
+};
+let $eventType = "";
+export const $getEventType = () => {
+    return $eventType;
+};
+export const $setEventType = (event_type) => {
+    $eventType = event_type;
+};
+/**
+ * @type {Event | null}
+ * @public
+ */
+let $event = null;
+export const $getEvent = () => {
+    return $event;
+};
+export const $setEvent = (event = null) => {
+    $event = event;
+};
+let $updated = false;
+export const $isUpdated = () => {
+    return $updated;
+};
+export const $doUpdated = (update = true) => {
+    $updated = update;
+};
+let $soundMixerVolume = 1;
+export const $getSoundMixerVolume = () => {
+    return $soundMixerVolume;
+};
+export const $setSoundMixerVolume = (volume) => {
+    $soundMixerVolume = volume;
+};