@p100-web/core 100.2.1 → 100.2.4

package/dist/GameContext.js

@@ -0,0 +1,698 @@
+import PFile from "./media/PFile";
+import { Platform, Language, Coordinates, PortTypes } from "./PEnums";
+import PEvent from "./PEvent";
+import PNode from "./PNode";
+import { PVariable } from "./PVariable";
+import PFileUsage from "./PFileUsage";
+import PScene from "./PScene";
+var Workers;
+(function (Workers) {
+    Workers[Workers["None"] = 0] = "None";
+    Workers[Workers["System"] = 1] = "System";
+    Workers[Workers["CameraControls"] = 2] = "CameraControls";
+    Workers[Workers["Animating"] = 4] = "Animating";
+    Workers[Workers["Updators"] = 8] = "Updators";
+    Workers[Workers["Admin"] = 16] = "Admin";
+    Workers[Workers["SceneLoader"] = 32] = "SceneLoader";
+    Workers[Workers["AdaptivePerformance"] = 64] = "AdaptivePerformance";
+})(Workers || (Workers = {}));
+export { Workers };
+export default class GameContext {
+    _owner;
+    _root = null;
+    _pcanvas = null;
+    _running = false;
+    _pnodeRenderer = null;
+    _engine = null;
+    _audioListener = null;
+    _componentFactory = null;
+    _assetLoader = null;
+    editor = false;
+    debug_fastVideo = false;
+    isAdmin() {
+        return false;
+    }
+    s3Url = "https://p100-pw.s3.eu-north-1.amazonaws.com/";
+    constructor(owner, platform, baseUrl) {
+        this._owner = owner;
+        this._platform = platform;
+        if (baseUrl)
+            this.s3Url = baseUrl + "/";
+    }
+    setEngine(engine) {
+        this._engine = engine;
+        if (engine) {
+            this._pnodeRenderer = engine.setupNodeRenderer(this);
+            this._componentFactory = engine.getComponentFactory();
+        }
+        else {
+            this._pnodeRenderer = null;
+            this._componentFactory = null;
+        }
+    }
+    getOwner() {
+        return this._owner;
+    }
+    //
+    //  PID
+    //
+    pid() {
+        console.error("MISSING PID");
+        return 0;
+    }
+    //
+    //  PRENDERER
+    //
+    getIEngine() {
+        return this._engine;
+    }
+    getEngine() {
+        return this._engine;
+    }
+    getNodeRenderer() {
+        return this._pnodeRenderer;
+    }
+    //
+    //  PCANVAS
+    //
+    getEngineScene() {
+        return this._pcanvas.getScene();
+    }
+    getCanvas() {
+        return this._pcanvas;
+    }
+    getPCanvas() {
+        return this._pcanvas;
+    }
+    getCanvasElement() {
+        return this._pcanvas?.getCanvasElement() || null;
+    }
+    setPCanvas(canvas) {
+        if (this._pcanvas !== null && canvas !== null) {
+            this.error("GameContext already had a canvas");
+            return;
+        }
+        this._pcanvas = canvas;
+    }
+    //
+    //  ASSETS
+    //
+    assetLoader() {
+        if (this._assetLoader === null) {
+            this._assetLoader = this._engine.setupAssetLoader(this);
+        }
+        return this._assetLoader;
+    }
+    async loadAssetsAsync() {
+        return this._assetLoader?.loadAsync();
+    }
+    //
+    //  MEDIA LOADERS
+    //
+    hasMediaQueue() {
+        return this._assetLoader?.hasQueue() || false;
+    }
+    //
+    //  IEmitter
+    //
+    getContext() {
+        return this;
+    }
+    //
+    //  LIFE CYCLE
+    //
+    /**
+     * Init and render scene
+     */
+    enable() {
+        this._sceneLoaderCounter = 0;
+        if (this._root) {
+            if (this._root.hasValidPlatform()) {
+                this._root.enable();
+                this._root.update();
+                this.setWorkFlag(Workers.System);
+                // pcanvas.enable();
+                this.clearWorkFlag(Workers.System);
+            }
+            else {
+                this.error("Root is not enabled or valid platform");
+            }
+        }
+    }
+    disable() {
+        this.disableInput();
+        this._root?.disable();
+    }
+    /**
+     * Destroy everything
+     */
+    dispose() {
+        this._assetLoader?.dispose();
+        this._assetLoader = null;
+        // Dispose ALL nodes, not just mounted ones
+        for (const node of this._nodes) {
+            node.dispose(false);
+        }
+        this._root = null;
+        this._nodes.length = 0;
+        this._events.length = 0;
+        this._fileUsages.length = 0;
+        this._pfiles.length = 0;
+        this._variables.length = 0;
+        if (this._audioListener !== null) {
+            const audioListener = this._audioListener;
+            if (audioListener.dispose) {
+                audioListener.dispose();
+            }
+        }
+        this.disposeCanvas();
+    }
+    /**
+     * Call when we need to dispose the old PCanvas and canvas element
+     */
+    disposeCanvas() {
+        this._pcanvas?.dispose();
+        this._assetLoader?.dispose();
+        this._assetLoader = null;
+        this._pcanvas = null;
+        this._engine = null;
+    }
+    /**
+     * use hard = true if we want to tear down and free all resources. Not
+     * to use while restarting.
+     */
+    soft_dispose() {
+        // Dispose ALL nodes, not just mounted ones
+        for (const node of this._nodes) {
+            node.dispose(false);
+        }
+        this._root = null;
+        this._nodes = [];
+    }
+    isLoading() {
+        return this.hasMediaQueue();
+    }
+    _sceneLoaderCounter = 0;
+    increaseSceneLoader() {
+        this._sceneLoaderCounter++;
+        if (this._sceneLoaderCounter === 1) {
+            this.setWorkFlag(Workers.SceneLoader);
+        }
+    }
+    decreaseSceneLoader() {
+        this._sceneLoaderCounter--;
+        if (this._sceneLoaderCounter === 0) {
+            this.clearWorkFlag(Workers.SceneLoader);
+        }
+    }
+    async play() {
+        if (this._root === null)
+            return;
+        if (this._running === true) {
+            console.error("play() GameContext was already running.");
+            return;
+        }
+        const pRootComponent = this._root.findComponent("PProjectRoot");
+        if (pRootComponent === null) {
+            this.error("play() PProjectRoot not found");
+            return;
+        }
+        this.increaseSceneLoader();
+        for (const variable of Object.values(this._variables)) {
+            variable.reset();
+        }
+        this._running = true;
+        await this.setupAudioListener();
+        this._root.play();
+        pRootComponent.native_OnPlay();
+        await this._assetLoader?.loadAsync();
+        pRootComponent.native_OnPlaying();
+        this._pcanvas?.updateEditorMode(false);
+        this._pcanvas.onSceneRunning();
+        this.decreaseSceneLoader();
+    }
+    stop() {
+        if (this._root === null)
+            return;
+        if (this._running === false)
+            return;
+        this._running = false;
+        for (const variable of Object.values(this._variables)) {
+            variable.reset();
+        }
+        this._root.stop();
+        this._pcanvas?.updateEditorMode(true);
+    }
+    //
+    //  WORKER
+    //
+    _workFlags = 0;
+    isWorking() {
+        return this._workFlags > 0;
+    }
+    setWorkFlag(worker) {
+        const wasWorking = this._workFlags > 0;
+        this._workFlags = this._workFlags | worker;
+        // console.log(
+        //   "setWorkState (" + Workers[worker] + ") _workFlags: ",
+        //   this._workFlags
+        // );
+        if (!wasWorking && this._workFlags > 0 && this._pcanvas !== null) {
+            this._pcanvas.onWorkStarted(this._workFlags);
+            this.getOwner().setWorkState(true);
+        }
+    }
+    clearWorkFlag(flag) {
+        const wasWorking = this._workFlags > 0;
+        this._workFlags = this._workFlags & ~flag;
+        // console.log(
+        //   "clearWorkState (" + Workers[flag] + ") _workState: ",
+        //   this._workFlags
+        // );
+        if (wasWorking && this._workFlags === 0 && this._pcanvas !== null) {
+            this._pcanvas.onWorkStopped(flag);
+            this.getOwner().setWorkState(false);
+        }
+    }
+    /**
+     * Render a single frame if sleeping
+     */
+    snooze() {
+        this._pcanvas.snooze();
+    }
+    //
+    //  NATIVE EVENTS
+    //
+    onClick = (node, ctrl, shift) => {
+        this._owner?.onClick(node, ctrl, shift);
+    };
+    onHoverEnter = (node) => {
+        this._owner?.onHoverEnter(node);
+    };
+    onHoverExit = (node) => {
+        this._owner?.onHoverExit(node);
+    };
+    //
+    //  PEVENTS
+    //
+    _events = [];
+    registerEvent(dbEvent) {
+        const pevent = new PEvent(dbEvent);
+        this._events.push(pevent);
+        return pevent;
+    }
+    getEvents() {
+        return this._events;
+    }
+    getEvent(id) {
+        console.log("dont use getEvent(id: string)");
+        return this._events.find((e) => e._id == id) || null;
+    }
+    getEventByPid(pid) {
+        return this._events.find((e) => e.pid === pid) || null;
+    }
+    getExternalEvent(name) {
+        return this._events.find((e) => e.external && e.name === name) || null;
+    }
+    //
+    //  PVARIABLES
+    //
+    _variables = [];
+    registerVariable(dbVariable) {
+        const pvariable = new PVariable(dbVariable);
+        this._variables.push(pvariable);
+        return pvariable;
+    }
+    getVariables() {
+        return this._variables;
+    }
+    getVariableByPid(pid) {
+        return this._variables.find((v) => v.pid === pid) || null;
+    }
+    getVariable(id) {
+        console.error("do not use getVariable(id: string)");
+        return this._variables.find((v) => v._id === id) || null;
+    }
+    //
+    //  FILES
+    //
+    // This is overriden by EGameContext
+    _pfiles = [];
+    // This is overriden by EGameContext
+    registerFile(dbItem) {
+        const item = new PFile(dbItem);
+        this._pfiles.push(item);
+        return item;
+    }
+    //
+    //  FILE USAGES
+    //
+    _fileUsages = [];
+    registerFileUsage(dbItem) {
+        const item = new PFileUsage(dbItem);
+        this._fileUsages.push(item);
+        return item;
+    }
+    findFileUsage(nodePid, componentPid, slot) {
+        return (this._fileUsages.find((f) => f.node === nodePid && f.component === componentPid && f.slot === slot) || null);
+    }
+    findFile(id) {
+        return this._pfiles.find((f) => f._id === id) || null;
+    }
+    /**
+     * Called when a component slot changes value. Used in admin.
+     */
+    setFileSlot(_fileSlot, _id) {
+        return null;
+    }
+    //
+    //  PLINKS
+    //
+    linkPorts(links, showErrors) {
+        // Link nodes to their ports
+        for (const link of links) {
+            const outPort = this.findOutEventPort(link.outPortType, link.outPid, link.outComponentPid, link.outPortId);
+            const inPort = this.findInEventPort(link.inPortType, link.inPid, link.inComponentPid, link.inPortId);
+            if (!outPort) {
+                if (showErrors)
+                    this.error("[Link Ports] out port not found");
+                continue;
+            }
+            if (!inPort) {
+                if (showErrors)
+                    this.error("[Link Ports] in port not found");
+                continue;
+            }
+            // Link
+            outPort.link(this, inPort, link);
+        }
+    }
+    //
+    //  PCOMPONENTS
+    //
+    createComponents(pnode, components) {
+        return components
+            .map((c) => this._componentFactory.component(c, pnode, this))
+            .filter((c) => c !== null);
+    }
+    //
+    //  NODES
+    //
+    _nodes = [];
+    createPNodeTree(dbItem, dbNodes, parent) {
+        const pnode = new PNode(dbItem, this, this._pnodeRenderer);
+        pnode.updateByComponent();
+        this._nodes.push(pnode);
+        if (parent) {
+            parent.add(pnode);
+        }
+        const res = dbNodes.filter((n) => n.parent === dbItem.pid);
+        for (const childNode of res) {
+            this.createPNodeTree(childNode, dbNodes, pnode);
+        }
+        return pnode;
+    }
+    /**
+     * [CREATE NODES]
+     * Create root node. For project or new nodes
+     */
+    createRootNode(dbRoot, dbNodes) {
+        // Create root PNode
+        const root = this.createPNodeTree(dbRoot, dbNodes);
+        root.traverse((n) => n.linkPorts());
+        return root;
+    }
+    findNode(id) {
+        return this._nodes.find((n) => n._id === id) || null;
+    }
+    findNodeByPid(pid) {
+        return this._nodes.find((n) => n.pid === pid) || null;
+    }
+    rerenderNode(_node) {
+        // Editor
+    }
+    editor_render() { }
+    getRoot() {
+        return this._root;
+    }
+    setRoot(root) {
+        this._root = root;
+    }
+    //
+    //  PORTS & LINKS
+    //
+    findInEventPort(portType, pid, component, portId) {
+        // Supports only
+        if (portType === PortTypes.Event) {
+            const pevent = this.getEventByPid(pid);
+            if (pevent)
+                return pevent.inPort;
+        }
+        else if (portType === PortTypes.Variable) {
+            const pvariable = this.getVariableByPid(pid);
+            if (pvariable)
+                return pvariable.inPort;
+        }
+        else if (portType === PortTypes.PNode) {
+            const pnode = this.findNodeByPid(pid);
+            if (pnode) {
+                const pcomponent = pnode.findComponentByPid(component);
+                if (pcomponent)
+                    return (pcomponent.inEventPorts.find((p) => p.portId === portId) || null);
+            }
+        }
+        return null;
+    }
+    findOutEventPort(portType, pid, component, portId) {
+        // Supports only
+        if (portType === PortTypes.Event) {
+            const pevent = this.getEventByPid(pid);
+            if (pevent)
+                return pevent.outPort;
+        }
+        else if (portType === PortTypes.Variable) {
+            const pvariable = this.getVariableByPid(pid);
+            if (pvariable)
+                return pvariable.outPort;
+        }
+        else if (portType === PortTypes.PNode) {
+            const pnode = this.findNodeByPid(pid);
+            if (pnode) {
+                const pcomponent = pnode.findComponentByPid(component);
+                if (pcomponent)
+                    return (pcomponent.outEventPorts.find((p) => p.portId === portId) || null);
+            }
+        }
+        return null;
+    }
+    findOutValuePort(link) {
+        // Supports only
+        if (link.portType === PortTypes.PNode) {
+            const pnode = this.findNodeByPid(link.pid);
+            if (pnode) {
+                const pcomponent = pnode.findComponentByPid(link.componentPid);
+                if (pcomponent) {
+                    return (pcomponent.outValuePorts.find((v) => v.portId === link.portId) ||
+                        null);
+                }
+            }
+        }
+        else if (link.portType === PortTypes.Variable) {
+            const pvariable = this.getVariableByPid(link.pid);
+            if (pvariable)
+                return pvariable.outValue;
+        }
+        else {
+            console.error("Unsupported valuePortType", link);
+        }
+        return null;
+    }
+    //
+    //  SCENES
+    //
+    _loadedScenePids = [];
+    _scenes = [];
+    registerScene = (dbScene) => {
+        const pscene = new PScene(dbScene);
+        this._scenes.push(pscene);
+        return pscene;
+    };
+    getScene(pid) {
+        return this._scenes.find((s) => s.pid === pid) || null;
+    }
+    isSceneLoaded(scenePid) {
+        return this._loadedScenePids.includes(scenePid);
+    }
+    getSceneRoot(pid) {
+        return (this._nodes.find((s) => s.parentPid === 0 && s.scenePid === pid) || null);
+    }
+    async loadScene(scenePid, loader, loadAssets, onLoadedEvent = null) {
+        const root = this.getSceneRoot(scenePid);
+        const pscene = this.getScene(scenePid);
+        if (!pscene || !root || !root.scenePid)
+            throw new Error("Scene not found");
+        if (pscene.isLoaded)
+            throw new Error("Scene was already loaded");
+        pscene.isLoaded = true;
+        this.increaseSceneLoader();
+        this._loadedScenePids.push(root.scenePid);
+        loader.add(root);
+        root.enable();
+        root.update();
+        this._owner.onLoadScene(root);
+        if (this.isRunning()) {
+            root.play();
+        }
+        if (loadAssets) {
+            await this._assetLoader?.loadAsync();
+        }
+        if (onLoadedEvent !== null)
+            onLoadedEvent.emit(root._id);
+        if (this.isRunning()) {
+            const pscene = root.findComponent("PSceneRoot");
+            pscene.outport_onSceneLoaded?.emit(root._id);
+        }
+        this.decreaseSceneLoader();
+    }
+    __unloadScene(pscene, root) {
+        if (!pscene.isLoaded)
+            throw new Error("Scene was not loaded");
+        pscene.isLoaded = false;
+        if (this.isRunning()) {
+            root.stop();
+        }
+        this._loadedScenePids = this._loadedScenePids.filter((id) => id !== root.scenePid);
+        this._owner.onUnloadScene(root);
+        root.disable();
+        root.removeFromParent();
+    }
+    unloadScene(pscene) {
+        const root = this.getSceneRoot(pscene.pid);
+        this.__unloadScene(pscene, root);
+    }
+    unloadSceneNode(root) {
+        const pscene = this.getScene(root.scenePid);
+        this.__unloadScene(pscene, root);
+    }
+    //
+    //  LAYERS
+    //
+    _mask = 1;
+    mask = () => {
+        return this._mask;
+    };
+    /**
+     * Camera layer changed
+     */
+    setLayers(mask) {
+        this._mask = mask;
+        // Loop through nodes and update visiblity
+        if (this._root) {
+            this._root.update();
+        }
+    }
+    //
+    //  COORDINATE SYSTEM
+    //
+    _coordinates = Coordinates.LeftHanded;
+    setCoordinates(coordinates) {
+        this._coordinates = coordinates;
+    }
+    /**
+     * Return coordinats of the selected engine
+     */
+    getEngineCoordinates() {
+        return this._engine.getCoordinates();
+    }
+    getCoordinates() {
+        return this._coordinates;
+    }
+    isInverted() {
+        return this._engine.getCoordinates() !== this._coordinates;
+    }
+    //
+    //  PLATFORM
+    //
+    _platform = Platform.Threejs;
+    setPlatform(platform) {
+        this._platform = platform;
+    }
+    platform() {
+        return this._platform;
+    }
+    //
+    //  LANGUAGES
+    //
+    _language = Language.English;
+    setLanguage(language) {
+        this._language = language;
+    }
+    language() {
+        return this._language;
+    }
+    //
+    //  RUNNING
+    //
+    isRunning() {
+        return this._running;
+    }
+    //
+    //  CAMERA
+    //
+    setCameraControlSettings(cameraSettings) {
+        const cameraControls = this._engine.setupCameraControls(this, cameraSettings);
+        this._pcanvas.setCameraControls(cameraControls);
+        return cameraControls;
+    }
+    getCameraControls() {
+        return this._pcanvas?.getCameraControls() || null;
+    }
+    //
+    //  AUDIO
+    //
+    async setupAudioListener() {
+        if (this._audioListener === null) {
+            this._audioListener = await this._engine.setupAudioListener();
+        }
+    }
+    getAudioListener() {
+        return this._audioListener;
+    }
+    //
+    //  INTERACTION
+    //
+    _inputEnabled = false;
+    enableInput() {
+        if (this._inputEnabled || !this._pcanvas)
+            return;
+        this._inputEnabled = true;
+        this._pcanvas.getCameraControls()?.enable();
+        this._pcanvas.enableRaycaster();
+    }
+    disableInput() {
+        if (!this._inputEnabled || !this._pcanvas)
+            return;
+        this._inputEnabled = false;
+        this._pcanvas.getCameraControls()?.disable();
+        this._pcanvas.disableRaycaster();
+    }
+    isInputEnabled() {
+        return this._inputEnabled;
+    }
+    //
+    //  TWEENS
+    //
+    addTween(tween) {
+        this._pcanvas?.addTween(tween);
+    }
+    //
+    //  NOTIFICATIONS
+    //
+    error(msg, details) {
+        this._owner.error(msg, details);
+    }
+    catch(error) {
+        this._owner.catch(error);
+    }
+}
+//# sourceMappingURL=GameContext.js.map