@woosh/meep-engine/src/engine/graphics/ecs/highlight/system/RenderableHighlightSystem.js

Pure JavaScript game engine. Fully featured and production ready.

import { System } from "../../../../ecs/System.js";
import { HighlightRenderElementSource } from "../plugin/HighlightRenderElementSource.js";
import Renderable from "../../../../ecs/renderable/Renderable.js";
import { RenderableFlags } from "../../../../ecs/renderable/RenderableFlags.js";
import Highlight from "../Highlight.js";
import { OutlineRenderPlugin } from "../plugin/OutlineRenderPlugin.js";


class Supplier extends HighlightRenderElementSource {
    /**
     *
     * @param {RenderableHighlightSystem} system
     */
    constructor(system) {
        super();

        /**
         *
         * @type {RenderableHighlightSystem}
         * @private
         */
        this.__system = system;

        /**
         *
         * @type {ObjectPoolFactory<HighlightRenderElement>}
         * @private
         */
        this.__pool = null;
        /**
         *
         * @type {HighlightRenderGroup}
         * @private
         */
        this.__group = null;
    }

    collect(pool, group) {

        this.__pool = pool;
        this.__group = group;

        const system = this.__system;

        /**
         *
         * @type {EntityManager}
         */
        const em = system.entityManager;

        const dataset = em.dataset;

        if (dataset === null) {
            return;
        }

        dataset.traverseEntities([Highlight, Renderable], this.__visit, this);
    }

    /**
     *
     * @param {Highlight} highlight
     * @param {Renderable} renderable
     * @param {number} entity
     * @private
     */
    __visit(highlight, renderable, entity) {


        if (!renderable.getFlag(RenderableFlags.InView)) {
            return;
        }


        const elements = highlight.elements;

        if (elements.isEmpty()) {
            // no elements
            return;
        }

        const renderElement = this.__pool.create();

        renderElement.definitions = elements.asArray();
        renderElement.object = renderable.object;

        this.__group.elements.add(renderElement);
    }
}

export class RenderableHighlightSystem extends System {
    /**
     *
     * @param {Engine} engine
     * @constructor
     */
    constructor(engine) {
        super();

        /**
         *
         * @type {Engine}
         * @private
         */
        this.__engine = engine;

        this.dependencies = [Highlight, Renderable];

        this.__element_source = new Supplier(this);

        /**
         *
         * @type {Reference<OutlineRenderPlugin>}
         * @private
         */
        this.__plugin_renderer_ref = null;


    }

    /**
     *
     * @param {EntityManager} entityManager
     * @param {function} readyCallback
     * @param {function} errorCallback
     */
    shutdown(entityManager, readyCallback, errorCallback) {
        try {

            if (this.__plugin_renderer_ref !== null) {

                this.__plugin_renderer_ref.getValue().removeSource(this.__element_source);

                this.__plugin_renderer_ref.release();

                this.__plugin_renderer_ref = null;
            }

            readyCallback();
        } catch (e) {
            errorCallback();
        }
    }

    /**
     *
     * @param {EntityManager} entityManager
     * @param {function} readyCallback
     * @param {function} errorCallback
     */
    startup(entityManager, readyCallback, errorCallback) {
        /**
         *
         * @type {EntityManager}
         */
        this.entityManager = entityManager;

        const engine = this.__engine;

        engine.plugins.acquire(OutlineRenderPlugin)
            .then(ref => {

                this.__plugin_renderer_ref = ref;

                /**
                 *
                 * @type {OutlineRenderPlugin}
                 */
                const plugin = ref.getValue();

                plugin.addSource(this.__element_source);

            }, errorCallback)
            .then(readyCallback);
    }
}