@needle-tools/engine 2.67.6-pre → 2.67.8-pre

package/lib/engine/engine_context.js

@@ -0,0 +1,855 @@
+import { Clock, DepthTexture, WebGLRenderer } from 'three';
+import * as THREE from 'three';
+import { Input } from './engine_input';
+import { Physics } from './engine_physics';
+import { Time } from './engine_time';
+import { NetworkConnection } from './engine_networking';
+import * as looputils from './engine_mainloop_utils';
+import * as utils from "./engine_utils";
+import { RenderPass } from "postprocessing";
+import { AssetDatabase } from './engine_assetdatabase';
+import { logHierarchy } from './engine_three_utils';
+import * as Stats from 'three/examples/jsm/libs/stats.module';
+import { RendererData } from './engine_rendererdata';
+import { Addressables } from './engine_addressables';
+import { Application } from './engine_application';
+import { LightDataRegistry } from './engine_lightdata';
+import { PlayerViewManager } from './engine_playerview';
+import { destroy, foreachComponent } from './engine_gameobject';
+import { ContextEvent, ContextRegistry } from './engine_context_registry';
+// import { createCameraWithOrbitControl } from '../engine-components/CameraUtils';
+const debug = utils.getParam("debugSetup");
+const stats = utils.getParam("stats");
+const debugActive = utils.getParam("debugactive");
+const debugframerate = utils.getParam("debugframerate");
+// this is where functions that setup unity scenes will be pushed into
+// those will be accessed from our custom html element to load them into their context
+export const build_scene_functions = {};
+export class ContextArgs {
+    name;
+    alias;
+    domElement;
+    renderer = undefined;
+    hash;
+    constructor(domElement) {
+        this.domElement = domElement ?? document.body;
+    }
+}
+export var FrameEvent;
+(function (FrameEvent) {
+    FrameEvent[FrameEvent["EarlyUpdate"] = 0] = "EarlyUpdate";
+    FrameEvent[FrameEvent["Update"] = 1] = "Update";
+    FrameEvent[FrameEvent["LateUpdate"] = 2] = "LateUpdate";
+    FrameEvent[FrameEvent["OnBeforeRender"] = 3] = "OnBeforeRender";
+    FrameEvent[FrameEvent["OnAfterRender"] = 4] = "OnAfterRender";
+    FrameEvent[FrameEvent["PrePhysicsStep"] = 9] = "PrePhysicsStep";
+    FrameEvent[FrameEvent["PostPhysicsStep"] = 10] = "PostPhysicsStep";
+    FrameEvent[FrameEvent["Undefined"] = -1] = "Undefined";
+})(FrameEvent || (FrameEvent = {}));
+export var XRSessionMode;
+(function (XRSessionMode) {
+    XRSessionMode["ImmersiveVR"] = "immersive-vr";
+    XRSessionMode["ImmersiveAR"] = "immersive-ar";
+})(XRSessionMode || (XRSessionMode = {}));
+export function registerComponent(script, context) {
+    if (!script)
+        return;
+    const new_scripts = context?.new_scripts ?? Context.Current.new_scripts;
+    if (!new_scripts.includes(script)) {
+        new_scripts.push(script);
+    }
+}
+export class Context {
+    static _current;
+    static get Current() {
+        return this._current;
+    }
+    static set Current(context) {
+        ContextRegistry.Current = context;
+        this._current = context;
+    }
+    name;
+    alias;
+    isManagedExternally = false;
+    isPaused = false;
+    runInBackground = false;
+    targetFrameRate;
+    /** used to append to loaded assets */
+    hash;
+    domElement;
+    get resolutionScaleFactor() { return this._resolutionScaleFactor; }
+    /** use to scale the resolution up or down of the renderer. default is 1 */
+    set resolutionScaleFactor(val) {
+        if (val === this._resolutionScaleFactor)
+            return;
+        if (typeof val !== "number")
+            return;
+        if (val <= 0) {
+            console.error("Invalid resolution scale factor", val);
+            return;
+        }
+        this._resolutionScaleFactor = val;
+        this.updateSize();
+    }
+    _resolutionScaleFactor = 1;
+    // domElement.clientLeft etc doesnt return absolute position
+    _boundingClientRectFrame = -1;
+    _boundingClientRect = null;
+    _domX;
+    _domY;
+    calculateBoundingClientRect() {
+        // workaround for mozilla webXR viewer
+        if (this.isInAR) {
+            this._domX = 0;
+            this._domY = 0;
+            return;
+        }
+        if (this._boundingClientRectFrame === this.time.frame)
+            return;
+        this._boundingClientRectFrame = this.time.frame;
+        this._boundingClientRect = this.domElement.getBoundingClientRect();
+        this._domX = this._boundingClientRect.x;
+        this._domY = this._boundingClientRect.y;
+    }
+    get domWidth() {
+        // for mozilla XR
+        if (this.isInAR)
+            return window.innerWidth;
+        return this.domElement.clientWidth;
+    }
+    get domHeight() {
+        // for mozilla XR
+        if (this.isInAR)
+            return window.innerHeight;
+        return this.domElement.clientHeight;
+    }
+    get domX() {
+        this.calculateBoundingClientRect();
+        return this._domX;
+    }
+    get domY() {
+        this.calculateBoundingClientRect();
+        return this._domY;
+    }
+    get isInXR() { return this.renderer.xr?.isPresenting || false; }
+    xrSessionMode = undefined;
+    get isInVR() { return this.xrSessionMode === XRSessionMode.ImmersiveVR; }
+    get isInAR() { return this.xrSessionMode === XRSessionMode.ImmersiveAR; }
+    get xrSession() { return this.renderer.xr?.getSession(); }
+    get arOverlayElement() {
+        const el = this.domElement;
+        if (typeof el.getAROverlayContainer === "function")
+            return el.getAROverlayContainer();
+        return this.domElement;
+    }
+    /** Current event of the update cycle */
+    get currentFrameEvent() {
+        return this._currentFrameEvent;
+    }
+    _currentFrameEvent = FrameEvent.Undefined;
+    scene;
+    renderer;
+    composer = null;
+    // all scripts
+    scripts = [];
+    scripts_pausedChanged = [];
+    // scripts with update event
+    scripts_earlyUpdate = [];
+    scripts_update = [];
+    scripts_lateUpdate = [];
+    scripts_onBeforeRender = [];
+    scripts_onAfterRender = [];
+    scripts_WithCorroutines = [];
+    coroutines = {};
+    get mainCamera() {
+        if (this.mainCameraComponent) {
+            const cam = this.mainCameraComponent;
+            if (!cam.cam)
+                cam.buildCamera();
+            return cam.cam;
+        }
+        return null;
+    }
+    mainCameraComponent;
+    post_setup_callbacks = [];
+    pre_update_callbacks = [];
+    pre_render_callbacks = [];
+    post_render_callbacks = [];
+    new_scripts = [];
+    new_script_start = [];
+    new_scripts_pre_setup_callbacks = [];
+    new_scripts_post_setup_callbacks = [];
+    application;
+    time;
+    input;
+    physics;
+    connection;
+    /**
+     * @deprecated AssetDataBase is deprecated
+     */
+    assets;
+    mainLight = null;
+    rendererData;
+    addressables;
+    lightmaps;
+    players;
+    get isCreated() { return this._isCreated; }
+    _sizeChanged = false;
+    _isCreated = false;
+    _isVisible = false;
+    _stats = stats ? Stats.default() : null;
+    constructor(args) {
+        this.name = args?.name || "";
+        this.alias = args?.alias;
+        this.domElement = args?.domElement || document.body;
+        this.hash = args?.hash;
+        if (args?.renderer) {
+            this.renderer = args.renderer;
+            this.isManagedExternally = true;
+        }
+        else {
+            this.renderer = new WebGLRenderer({
+                antialias: true
+            });
+            // some tonemapping other than "NONE" is required for adjusting exposure with EXR environments
+            this.renderer.toneMappingExposure = 1; // range [0...inf] instead of the usual -15..15
+            this.renderer.toneMapping = THREE.NoToneMapping; // could also set to LinearToneMapping, ACESFilmicToneMapping
+            this.renderer.setClearColor(new THREE.Color('lightgrey'), 0);
+            // @ts-ignore
+            this.renderer.antialias = true;
+            // @ts-ignore
+            this.renderer.alpha = false;
+            this.renderer.shadowMap.enabled = true;
+            this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+            this.renderer.setSize(this.domWidth, this.domHeight);
+            this.renderer.outputEncoding = THREE.sRGBEncoding;
+            this.renderer.physicallyCorrectLights = true;
+        }
+        this.scene = new THREE.Scene();
+        ContextRegistry.register(this);
+        this.application = new Application(this);
+        this.time = new Time();
+        this.input = new Input(this);
+        this.physics = new Physics(this);
+        this.connection = new NetworkConnection(this);
+        this.assets = new AssetDatabase();
+        this.rendererData = new RendererData(this);
+        this.addressables = new Addressables(this);
+        this.lightmaps = new LightDataRegistry(this);
+        this.players = new PlayerViewManager(this);
+        const resizeCallback = () => this._sizeChanged = true;
+        window.addEventListener('resize', resizeCallback);
+        this._disposeCallbacks.push(() => window.removeEventListener('resize', resizeCallback));
+        const resizeObserver = new ResizeObserver(_ => this._sizeChanged = true);
+        resizeObserver.observe(this.domElement);
+        this._disposeCallbacks.push(() => resizeObserver.disconnect());
+        this._intersectionObserver = new IntersectionObserver(entries => {
+            this._isVisible = entries[0].isIntersecting;
+        });
+        this._disposeCallbacks.push(() => this._intersectionObserver?.disconnect());
+    }
+    _intersectionObserver = null;
+    internalOnUpdateVisible() {
+        this._intersectionObserver?.disconnect();
+        this._intersectionObserver?.observe(this.domElement);
+    }
+    _disposeCallbacks = [];
+    // private _requestSizeUpdate : boolean = false;
+    updateSize() {
+        if (!this.isManagedExternally && !this.renderer.xr.isPresenting) {
+            this._sizeChanged = false;
+            const scaleFactor = this.resolutionScaleFactor;
+            const width = this.domWidth * scaleFactor;
+            const height = this.domHeight * scaleFactor;
+            const camera = this.mainCamera;
+            this.updateAspect(camera);
+            this.renderer.setSize(width, height);
+            this.renderer.setPixelRatio(window.devicePixelRatio);
+            // avoid setting pixel values here since this can cause pingpong updates
+            // e.g. when system scale is set to 125%
+            // https://github.com/needle-tools/needle-engine-support/issues/69
+            this.renderer.domElement.style.width = "100%";
+            this.renderer.domElement.style.height = "100%";
+            if (this.composer) {
+                this.composer.setSize?.call(this.composer, width, height);
+                if ("setPixelRatio" in this.composer && typeof this.composer.setPixelRatio === "function")
+                    this.composer.setPixelRatio?.call(this.composer, window.devicePixelRatio);
+            }
+        }
+    }
+    updateAspect(camera, width, height) {
+        if (!camera)
+            return;
+        if (width === undefined)
+            width = this.domWidth;
+        if (height === undefined)
+            height = this.domHeight;
+        const pa = camera.aspect;
+        camera.aspect = width / height;
+        if (pa !== camera.aspect)
+            camera.updateProjectionMatrix();
+    }
+    onCreate(buildScene, opts) {
+        if (this._isCreated) {
+            console.warn("Context already created");
+            return null;
+        }
+        this._isCreated = true;
+        return this.internalOnCreate(buildScene, opts);
+    }
+    onDestroy() {
+        if (!this._isCreated)
+            return;
+        this._isCreated = false;
+        destroy(this.scene, true);
+        this.renderer?.setAnimationLoop(null);
+        if (!this.isManagedExternally) {
+            this.renderer?.dispose();
+        }
+        for (const cb of this._disposeCallbacks) {
+            try {
+                cb();
+            }
+            catch (e) {
+                console.error("Error in on dispose callback:", e, cb);
+            }
+        }
+        if (this.domElement?.parentElement) {
+            this.domElement.parentElement.removeChild(this.domElement);
+        }
+        ContextRegistry.dispatchCallback(ContextEvent.ContextDestroyed, this);
+        ContextRegistry.unregister(this);
+    }
+    registerCoroutineUpdate(script, coroutine, evt) {
+        if (!this.coroutines[evt])
+            this.coroutines[evt] = [];
+        this.coroutines[evt].push({ comp: script, main: coroutine });
+        return coroutine;
+    }
+    unregisterCoroutineUpdate(coroutine, evt) {
+        if (!this.coroutines[evt])
+            return;
+        const idx = this.coroutines[evt].findIndex(c => c.main === coroutine);
+        if (idx >= 0)
+            this.coroutines[evt].splice(idx, 1);
+    }
+    stopAllCoroutinesFrom(script) {
+        for (const evt in this.coroutines) {
+            const rout = this.coroutines[evt];
+            for (let i = rout.length - 1; i >= 0; i--) {
+                const r = rout[i];
+                if (r.comp === script) {
+                    rout.splice(i, 1);
+                }
+            }
+        }
+    }
+    _cameraStack = [];
+    setCurrentCamera(cam) {
+        if (!cam)
+            return;
+        if (!cam.cam)
+            cam.buildCamera(); // < to build camera
+        if (!cam.cam) {
+            console.warn("Camera component is missing camera", cam);
+            return;
+        }
+        const index = this._cameraStack.indexOf(cam);
+        if (index >= 0)
+            this._cameraStack.splice(index, 1);
+        this._cameraStack.push(cam);
+        this.mainCameraComponent = cam;
+        const camera = cam.cam;
+        if (camera.isPerspectiveCamera)
+            this.updateAspect(camera);
+        this.mainCameraComponent?.applyClearFlagsIfIsActiveCamera();
+    }
+    removeCamera(cam) {
+        if (!cam)
+            return;
+        const index = this._cameraStack.indexOf(cam);
+        if (index >= 0)
+            this._cameraStack.splice(index, 1);
+        if (this.mainCameraComponent === cam) {
+            this.mainCameraComponent = undefined;
+            if (this._cameraStack.length > 0) {
+                const last = this._cameraStack[this._cameraStack.length - 1];
+                this.setCurrentCamera(last);
+            }
+        }
+    }
+    _onBeforeRenderListeners = {};
+    /** use this to subscribe to onBeforeRender events on threejs objects */
+    addBeforeRenderListener(target, callback) {
+        if (!this._onBeforeRenderListeners[target.uuid]) {
+            this._onBeforeRenderListeners[target.uuid] = [];
+            const onBeforeRenderCallback = (renderer, scene, camera, geometry, material, group) => {
+                const arr = this._onBeforeRenderListeners[target.uuid];
+                if (!arr)
+                    return;
+                for (let i = 0; i < arr.length; i++) {
+                    const fn = arr[i];
+                    fn(renderer, scene, camera, geometry, material, group);
+                }
+            };
+            target.onBeforeRender = onBeforeRenderCallback;
+        }
+        this._onBeforeRenderListeners[target.uuid].push(callback);
+    }
+    removeBeforeRenderListener(target, callback) {
+        if (this._onBeforeRenderListeners[target.uuid]) {
+            const arr = this._onBeforeRenderListeners[target.uuid];
+            const idx = arr.indexOf(callback);
+            if (idx >= 0)
+                arr.splice(idx, 1);
+        }
+    }
+    _requireDepthTexture = false;
+    _requireColorTexture = false;
+    _renderTarget;
+    _isRendering = false;
+    get isRendering() { return this._isRendering; }
+    setRequireDepth(val) {
+        this._requireDepthTexture = val;
+    }
+    setRequireColor(val) {
+        this._requireColorTexture = val;
+    }
+    get depthTexture() {
+        return this._renderTarget?.depthTexture || null;
+    }
+    get opaqueColorTexture() {
+        return this._renderTarget?.texture || null;
+    }
+    /** returns true if the dom element is visible on screen */
+    get isVisibleToUser() {
+        if (this.isInXR)
+            return true;
+        if (!this._isVisible)
+            return false;
+        const style = getComputedStyle(this.domElement);
+        return style.visibility !== "hidden" && style.display !== "none" && style.opacity !== "0";
+    }
+    async internalOnCreate(buildScene, opts) {
+        // TODO: we could configure if we need physics
+        await this.physics.createWorld();
+        // load and create scene
+        let prepare_succeeded = true;
+        try {
+            Context.Current = this;
+            if (buildScene)
+                await buildScene(this, opts);
+        }
+        catch (err) {
+            console.error(err);
+            prepare_succeeded = false;
+        }
+        if (!prepare_succeeded)
+            return;
+        this.internalOnUpdateVisible();
+        // console.log(prepare_succeeded);
+        if (!this.isManagedExternally)
+            this.domElement.prepend(this.renderer.domElement);
+        Context._current = this;
+        // Setup
+        Context._current = this;
+        for (let i = 0; i < this.new_scripts.length; i++) {
+            const script = this.new_scripts[i];
+            if (script.gameObject !== undefined && script.gameObject !== null) {
+                if (script.gameObject.userData === undefined)
+                    script.gameObject.userData = {};
+                if (script.gameObject.userData.components === undefined)
+                    script.gameObject.userData.components = [];
+                const arr = script.gameObject.userData.components;
+                if (!arr.includes(script))
+                    arr.push(script);
+            }
+            // if (script.gameObject && !this.raycastTargets.includes(script.gameObject)) {
+            // 	this.raycastTargets.push(script.gameObject);
+            // }
+        }
+        // const context = new SerializationContext(this.scene);
+        // for (let i = 0; i < this.new_scripts.length; i++) {
+        // 	const script = this.new_scripts[i];
+        // 	const ser = script as unknown as ISerializable;
+        // 	if (ser.$serializedTypes === undefined) continue;
+        // 	context.context = this;
+        // 	context.object = script.gameObject;
+        // 	deserializeObject(ser, script, context);
+        // }
+        // resolve post setup callbacks (things that rely on threejs objects having references to components)
+        if (this.post_setup_callbacks) {
+            for (let i = 0; i < this.post_setup_callbacks.length; i++) {
+                Context._current = this;
+                await this.post_setup_callbacks[i](this);
+            }
+        }
+        if (!this.mainCamera) {
+            Context._current = this;
+            let camera = null;
+            foreachComponent(this.scene, comp => {
+                const cam = comp;
+                if (cam?.isCamera) {
+                    looputils.updateActiveInHierarchyWithoutEventCall(cam.gameObject);
+                    if (!cam.activeAndEnabled)
+                        return undefined;
+                    if (cam.tag === "MainCamera") {
+                        camera = cam;
+                        return true;
+                    }
+                    else
+                        camera = cam;
+                }
+                return undefined;
+            });
+            if (camera) {
+                this.setCurrentCamera(camera);
+            }
+            else {
+                ContextRegistry.dispatchCallback(ContextEvent.MissingCamera, this);
+                if (!this.mainCamera && !this.isManagedExternally)
+                    console.error("MISSING camera", this);
+            }
+        }
+        Context._current = this;
+        looputils.processNewScripts(this);
+        // const mainCam = this.mainCameraComponent as Camera;
+        // if (mainCam) {
+        // 	mainCam.applyClearFlagsIfIsActiveCamera();
+        // }
+        if (!this.isManagedExternally && this.composer && this.mainCamera) {
+            const renderPass = new RenderPass(this.scene, this.mainCamera);
+            this.renderer.setSize(this.domWidth, this.domHeight);
+            this.composer.addPass(renderPass);
+            this.composer.setSize(this.domWidth, this.domHeight);
+        }
+        this._sizeChanged = true;
+        if (this._stats) {
+            this._stats.showPanel(1);
+            this.domElement.appendChild(this._stats.dom);
+        }
+        this.renderer.setAnimationLoop(this.render.bind(this));
+        if (debug)
+            logHierarchy(this.scene, true);
+        ContextRegistry.dispatchCallback(ContextEvent.ContextCreated, this);
+    }
+    _accumulatedTime = 0;
+    _framerateClock = new Clock();
+    render(_, frame) {
+        this._currentFrameEvent = FrameEvent.Undefined;
+        if (this.isInXR === false && this.targetFrameRate !== undefined) {
+            this._accumulatedTime += this._framerateClock.getDelta();
+            if (this._accumulatedTime < (1 / this.targetFrameRate)) {
+                return;
+            }
+            this._accumulatedTime = 0;
+        }
+        this._stats?.begin();
+        Context._current = this;
+        if (this.onHandlePaused())
+            return;
+        Context._current = this;
+        this.time.update();
+        if (debugframerate)
+            console.log("FPS", (this.time.smoothedFps).toFixed(0));
+        looputils.processNewScripts(this);
+        looputils.updateIsActive(this.scene);
+        looputils.processStart(this);
+        while (this._cameraStack.length > 0 && (!this.mainCameraComponent || this.mainCameraComponent.destroyed)) {
+            this._cameraStack.splice(this._cameraStack.length - 1, 1);
+            const last = this._cameraStack[this._cameraStack.length - 1];
+            this.setCurrentCamera(last);
+        }
+        if (this.pre_update_callbacks) {
+            for (const i in this.pre_update_callbacks) {
+                this.pre_update_callbacks[i]();
+            }
+        }
+        this._currentFrameEvent = FrameEvent.EarlyUpdate;
+        for (let i = 0; i < this.scripts_earlyUpdate.length; i++) {
+            const script = this.scripts_earlyUpdate[i];
+            if (!script.activeAndEnabled)
+                continue;
+            if (script.earlyUpdate !== undefined) {
+                Context._current = this;
+                script.earlyUpdate();
+            }
+        }
+        this.executeCoroutines(FrameEvent.EarlyUpdate);
+        if (this.onHandlePaused())
+            return;
+        this._currentFrameEvent = FrameEvent.Update;
+        for (let i = 0; i < this.scripts_update.length; i++) {
+            const script = this.scripts_update[i];
+            if (!script.activeAndEnabled)
+                continue;
+            if (script.update !== undefined) {
+                Context._current = this;
+                script.update();
+            }
+        }
+        this.executeCoroutines(FrameEvent.Update);
+        if (this.onHandlePaused())
+            return;
+        this._currentFrameEvent = FrameEvent.LateUpdate;
+        for (let i = 0; i < this.scripts_lateUpdate.length; i++) {
+            const script = this.scripts_lateUpdate[i];
+            if (!script.activeAndEnabled)
+                continue;
+            if (script.lateUpdate !== undefined) {
+                Context._current = this;
+                script.lateUpdate();
+            }
+        }
+        // this.mainLight = null;
+        this.executeCoroutines(FrameEvent.LateUpdate);
+        if (this.onHandlePaused())
+            return;
+        const physicsSteps = 1;
+        const dt = this.time.deltaTime / physicsSteps;
+        for (let i = 0; i < physicsSteps; i++) {
+            this._currentFrameEvent = FrameEvent.PrePhysicsStep;
+            this.executeCoroutines(FrameEvent.PrePhysicsStep);
+            this.physics.step(dt);
+            this._currentFrameEvent = FrameEvent.PostPhysicsStep;
+            this.executeCoroutines(FrameEvent.PostPhysicsStep);
+        }
+        this.physics.postStep();
+        if (this.onHandlePaused())
+            return;
+        if (this.isVisibleToUser) {
+            this._currentFrameEvent = FrameEvent.OnBeforeRender;
+            // should we move these callbacks in the regular three onBeforeRender events?
+            for (let i = 0; i < this.scripts_onBeforeRender.length; i++) {
+                const script = this.scripts_onBeforeRender[i];
+                if (!script.activeAndEnabled)
+                    continue;
+                // if(script.isActiveAndEnabled === false) continue;
+                if (script.onBeforeRender !== undefined) {
+                    Context._current = this;
+                    script.onBeforeRender(frame);
+                }
+            }
+            this.executeCoroutines(FrameEvent.OnBeforeRender);
+            if (this._sizeChanged)
+                this.updateSize();
+            if (this.pre_render_callbacks) {
+                for (const i in this.pre_render_callbacks) {
+                    this.pre_render_callbacks[i]();
+                }
+            }
+            if (!this.isManagedExternally) {
+                looputils.runPrewarm(this);
+                this._currentFrameEvent = FrameEvent.Undefined;
+                this.renderNow();
+                this._currentFrameEvent = FrameEvent.OnAfterRender;
+            }
+            for (let i = 0; i < this.scripts_onAfterRender.length; i++) {
+                const script = this.scripts_onAfterRender[i];
+                if (!script.activeAndEnabled)
+                    continue;
+                if (script.onAfterRender !== undefined) {
+                    Context._current = this;
+                    script.onAfterRender();
+                }
+            }
+            this.executeCoroutines(FrameEvent.OnAfterRender);
+            if (this.post_render_callbacks) {
+                for (const i in this.post_render_callbacks) {
+                    this.post_render_callbacks[i]();
+                }
+            }
+        }
+        this._currentFrameEvent = -1;
+        this.connection.sendBufferedMessagesNow();
+        this._stats?.end();
+        if (this.time.frame === 1) {
+            this.domElement.dispatchEvent(new CustomEvent("ready"));
+        }
+    }
+    renderNow(camera) {
+        if (!camera) {
+            camera = this.mainCamera;
+            if (!camera)
+                return false;
+        }
+        this._isRendering = true;
+        this.renderRequiredTextures();
+        // if (camera === this.mainCameraComponent?.cam) {
+        // 	if (this.mainCameraComponent.activeTexture) {
+        // 	}
+        // }
+        if (this.composer && !this.isInXR) {
+            this.composer.render(this.time.deltaTime);
+        }
+        else if (camera) {
+            this.renderer.render(this.scene, camera);
+        }
+        this._isRendering = false;
+        return true;
+    }
+    /** returns true if we should return out of the frame loop */
+    _wasPaused = false;
+    onHandlePaused() {
+        const paused = this.evaluatePaused();
+        if (this._wasPaused !== paused) {
+            if (debugActive)
+                console.log("Paused?", paused, "context:" + this.alias);
+            for (let i = 0; i < this.scripts_pausedChanged.length; i++) {
+                const script = this.scripts_pausedChanged[i];
+                if (!script.activeAndEnabled)
+                    continue;
+                if (script.onPausedChanged !== undefined) {
+                    Context._current = this;
+                    script.onPausedChanged(paused, this._wasPaused);
+                }
+            }
+        }
+        this._wasPaused = paused;
+        return paused;
+    }
+    evaluatePaused() {
+        if (this.isInXR)
+            return false;
+        if (this.isPaused)
+            return true;
+        // if the element is not visible use the runInBackground flag to determine if we should continue
+        if (this.runInBackground) {
+            return false;
+        }
+        const paused = !this.isVisibleToUser;
+        return paused;
+    }
+    renderRequiredTextures() {
+        if (!this.mainCamera)
+            return;
+        if (!this._requireDepthTexture && !this._requireColorTexture)
+            return;
+        if (!this._renderTarget) {
+            this._renderTarget = new THREE.WebGLRenderTarget(this.domWidth, this.domHeight);
+            if (this._requireDepthTexture) {
+                const dt = new DepthTexture(this.domWidth, this.domHeight);
+                ;
+                this._renderTarget.depthTexture = dt;
+            }
+            if (this._requireColorTexture) {
+                this._renderTarget.texture = new THREE.Texture();
+                this._renderTarget.texture.generateMipmaps = false;
+                this._renderTarget.texture.minFilter = THREE.NearestFilter;
+                this._renderTarget.texture.magFilter = THREE.NearestFilter;
+                this._renderTarget.texture.format = THREE.RGBAFormat;
+            }
+        }
+        const rt = this._renderTarget;
+        if (rt.texture) {
+            rt.texture.encoding = this.renderer.outputEncoding;
+        }
+        const prevTarget = this.renderer.getRenderTarget();
+        this.renderer.setRenderTarget(rt);
+        this.renderer.render(this.scene, this.mainCamera);
+        this.renderer.setRenderTarget(prevTarget);
+    }
+    executeCoroutines(evt) {
+        if (this.coroutines[evt]) {
+            const evts = this.coroutines[evt];
+            for (let i = 0; i < evts.length; i++) {
+                try {
+                    const evt = evts[i];
+                    // TODO we might want to keep coroutines playing even if the component is disabled or inactive
+                    const remove = !evt.comp || evt.comp.destroyed || !evt.main || evt.comp["enabled"] === false;
+                    if (remove) {
+                        evts.splice(i, 1);
+                        --i;
+                        continue;
+                    }
+                    const iter = evt.chained;
+                    if (iter && iter.length > 0) {
+                        const last = iter[iter.length - 1];
+                        const res = last.next();
+                        if (res.done) {
+                            iter.pop();
+                        }
+                        if (isGenerator(res)) {
+                            if (!evt.chained)
+                                evt.chained = [];
+                            evt.chained.push(res.value);
+                        }
+                        if (!res.done)
+                            continue;
+                    }
+                    const res = evt.main.next();
+                    if (res.done === true) {
+                        evts.splice(i, 1);
+                        --i;
+                        continue;
+                    }
+                    const val = res.value;
+                    if (isGenerator(val)) {
+                        // invoke once if its a generator
+                        // this means e.g. WaitForFrame(1) works and will capture
+                        // the frame it was created
+                        const gen = val;
+                        const res = gen.next();
+                        if (res.done)
+                            continue;
+                        if (!evt.chained)
+                            evt.chained = [];
+                        evt.chained.push(val);
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+        function isGenerator(val) {
+            if (val) {
+                if (val.next && val.return) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
+// const scene = new THREE.Scene();
+// const useComposer = utils.getParam("postfx");
+// const renderer = new WebGLRenderer({ antialias: true });
+// const composer = useComposer ? new EffectComposer(renderer) : undefined;
+// renderer.setClearColor(new THREE.Color('lightgrey'), 0)
+// renderer.antialias = true;
+// renderer.alpha = false;
+// renderer.shadowMap.enabled = true;
+// renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+// renderer.setSize(window.innerWidth, window.innerHeight);
+// renderer.outputEncoding = THREE.sRGBEncoding;
+// renderer.physicallyCorrectLights = true;
+// document.body.appendChild(renderer.domElement);
+// // generation pushes loading requests in this array
+// const sceneData: {
+//     mainCamera: THREE.Camera | undefined
+// } = {
+//     preparing: [],
+//     resolving: [],
+//     scripts: [],
+//     raycastTargets: [],
+//     mainCamera: undefined,
+//     mainCameraComponent: undefined,
+// };
+// // contains a list of functions to be called after loading is done
+// const post_setup_callbacks = [];
+// const pre_render_Callbacks = [];
+// const post_render_callbacks = [];
+// const new_scripts = [];
+// const new_scripts_post_setup_callbacks = [];
+// const new_scripts_pre_setup_callbacks = [];
+// export {
+//     scene, renderer, composer,
+//     new_scripts,
+//     new_scripts_post_setup_callbacks, new_scripts_pre_setup_callbacks,
+//     sceneData,
+//     post_setup_callbacks,
+//     pre_render_Callbacks,
+//     post_render_callbacks
+// }
+//# sourceMappingURL=engine_context.js.map