@needle-tools/engine 3.28.6-beta → 3.28.7-beta.1

package/lib/engine/engine_context_registry.d.ts

@@ -1,50 +1,50 @@
-import { type IComponent, type IContext, type LoadedGLTF } from "./engine_types.js";
-export declare enum ContextEvent {
-    /** called when the context is registered to the registry, the context is not fully initialized at this point */
-    ContextRegistered = "ContextRegistered",
-    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
-    ContextCreationStart = "ContextCreationStart",
-    /** Called when the context has been created, before the first frame */
-    ContextCreated = "ContextCreated",
-    /** Called after the first frame has been rendered after creation */
-    ContextFirstFrameRendered = "ContextFirstFrameRendered",
-    /** Called when the context has been destroyed */
-    ContextDestroyed = "ContextDestroyed",
-    /** Called when the context could not find a camera during creation */
-    MissingCamera = "MissingCamera",
-    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
-    ContextClearing = "ContextClearing",
-    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
-    ContextCleared = "ContextCleared"
-}
-export type ContextEventArgs = {
-    event: ContextEvent;
-    context: IContext;
-    files?: LoadedGLTF[];
-};
-export type ContextCallback = (evt: ContextEventArgs) => void | Promise<any> | IComponent;
-/** Use to register to various Needle Engine context events and to get access to all current instances
- * e.g. when being created in the DOM
- * */
-export declare class ContextRegistry {
-    /** The currently active (rendering) Needle Engine context */
-    static get Current(): IContext;
-    /** @internal */
-    static set Current(ctx: IContext);
-    /** Returns the array of all registered Needle Engine contexts. Do not modify */
-    static get All(): IContext[];
-    /** All currently registered Needle Engine contexts. Do not modify */
-    static Registered: IContext[];
-    /** @internal Internal use only */
-    static register(ctx: IContext): void;
-    /** @internal Internal use only */
-    static unregister(ctx: IContext): void;
-    private static _callbacks;
-    static registerCallback(evt: ContextEvent, callback: ContextCallback): void;
-    static unregisterCallback(evt: ContextEvent, callback: ContextCallback): void;
-    /** @internal */
-    static dispatchCallback(evt: ContextEvent, context: IContext, extras?: object): true | Promise<any[]>;
-    static addContextCreatedCallback(callback: ContextCallback): void;
-    static addContextDestroyedCallback(callback: ContextCallback): void;
-}
-export { ContextRegistry as NeedleEngine };
+import { type IComponent, type IContext, type LoadedGLTF } from "./engine_types.js";
+export declare enum ContextEvent {
+    /** called when the context is registered to the registry, the context is not fully initialized at this point */
+    ContextRegistered = "ContextRegistered",
+    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
+    ContextCreationStart = "ContextCreationStart",
+    /** Called when the context has been created, before the first frame */
+    ContextCreated = "ContextCreated",
+    /** Called after the first frame has been rendered after creation */
+    ContextFirstFrameRendered = "ContextFirstFrameRendered",
+    /** Called when the context has been destroyed */
+    ContextDestroyed = "ContextDestroyed",
+    /** Called when the context could not find a camera during creation */
+    MissingCamera = "MissingCamera",
+    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
+    ContextClearing = "ContextClearing",
+    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
+    ContextCleared = "ContextCleared"
+}
+export type ContextEventArgs = {
+    event: ContextEvent;
+    context: IContext;
+    files?: LoadedGLTF[];
+};
+export type ContextCallback = (evt: ContextEventArgs) => void | Promise<any> | IComponent;
+/** Use to register to various Needle Engine context events and to get access to all current instances
+ * e.g. when being created in the DOM
+ * */
+export declare class ContextRegistry {
+    /** The currently active (rendering) Needle Engine context */
+    static get Current(): IContext;
+    /** @internal */
+    static set Current(ctx: IContext);
+    /** Returns the array of all registered Needle Engine contexts. Do not modify */
+    static get All(): IContext[];
+    /** All currently registered Needle Engine contexts. Do not modify */
+    static Registered: IContext[];
+    /** @internal Internal use only */
+    static register(ctx: IContext): void;
+    /** @internal Internal use only */
+    static unregister(ctx: IContext): void;
+    private static _callbacks;
+    static registerCallback(evt: ContextEvent, callback: ContextCallback): void;
+    static unregisterCallback(evt: ContextEvent, callback: ContextCallback): void;
+    /** @internal */
+    static dispatchCallback(evt: ContextEvent, context: IContext, extras?: object): true | Promise<any[]>;
+    static addContextCreatedCallback(callback: ContextCallback): void;
+    static addContextDestroyedCallback(callback: ContextCallback): void;
+}
+export { ContextRegistry as NeedleEngine };

package/lib/engine/engine_context_registry.js

@@ -1,90 +1,90 @@
-export var ContextEvent;
-(function (ContextEvent) {
-    /** called when the context is registered to the registry, the context is not fully initialized at this point */
-    ContextEvent["ContextRegistered"] = "ContextRegistered";
-    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
-    ContextEvent["ContextCreationStart"] = "ContextCreationStart";
-    /** Called when the context has been created, before the first frame */
-    ContextEvent["ContextCreated"] = "ContextCreated";
-    /** Called after the first frame has been rendered after creation */
-    ContextEvent["ContextFirstFrameRendered"] = "ContextFirstFrameRendered";
-    /** Called when the context has been destroyed */
-    ContextEvent["ContextDestroyed"] = "ContextDestroyed";
-    /** Called when the context could not find a camera during creation */
-    ContextEvent["MissingCamera"] = "MissingCamera";
-    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
-    ContextEvent["ContextClearing"] = "ContextClearing";
-    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
-    ContextEvent["ContextCleared"] = "ContextCleared";
-})(ContextEvent || (ContextEvent = {}));
-/** Use to register to various Needle Engine context events and to get access to all current instances
- * e.g. when being created in the DOM
- * */
-export class ContextRegistry {
-    /** The currently active (rendering) Needle Engine context */
-    static get Current() {
-        return globalThis["NeedleEngine.Context.Current"];
-    }
-    /** @internal */
-    static set Current(ctx) {
-        globalThis["NeedleEngine.Context.Current"] = ctx;
-    }
-    /** Returns the array of all registered Needle Engine contexts. Do not modify */
-    static get All() {
-        return this.Registered;
-    }
-    /** All currently registered Needle Engine contexts. Do not modify */
-    static Registered = [];
-    /** @internal Internal use only */
-    static register(ctx) {
-        this.Registered.push(ctx);
-        this.dispatchCallback(ContextEvent.ContextRegistered, ctx);
-    }
-    /** @internal Internal use only */
-    static unregister(ctx) {
-        const index = this.Registered.indexOf(ctx);
-        if (index === -1)
-            return;
-        this.Registered.splice(index, 1);
-    }
-    static _callbacks = {};
-    static registerCallback(evt, callback) {
-        if (!this._callbacks[evt])
-            this._callbacks[evt] = [];
-        this._callbacks[evt].push(callback);
-    }
-    static unregisterCallback(evt, callback) {
-        if (!this._callbacks[evt])
-            return;
-        const index = this._callbacks[evt].indexOf(callback);
-        if (index === -1)
-            return;
-        this._callbacks[evt].splice(index, 1);
-    }
-    /** @internal */
-    static dispatchCallback(evt, context, extras) {
-        if (!this._callbacks[evt])
-            return true;
-        const cbArgs = { event: evt, context };
-        if (extras) {
-            for (const key in extras) {
-                cbArgs[key] = extras[key];
-            }
-        }
-        const promises = new Array();
-        this._callbacks[evt].forEach(cb => {
-            const res = cb(cbArgs);
-            if (res instanceof Promise)
-                promises.push(res);
-        });
-        return Promise.all(promises);
-    }
-    static addContextCreatedCallback(callback) {
-        this.registerCallback(ContextEvent.ContextCreated, callback);
-    }
-    static addContextDestroyedCallback(callback) {
-        this.registerCallback(ContextEvent.ContextDestroyed, callback);
-    }
-}
-export { ContextRegistry as NeedleEngine };
+export var ContextEvent;
+(function (ContextEvent) {
+    /** called when the context is registered to the registry, the context is not fully initialized at this point */
+    ContextEvent["ContextRegistered"] = "ContextRegistered";
+    /** called before the first glb is loaded, can be used to initialize physics engine, is awaited */
+    ContextEvent["ContextCreationStart"] = "ContextCreationStart";
+    /** Called when the context has been created, before the first frame */
+    ContextEvent["ContextCreated"] = "ContextCreated";
+    /** Called after the first frame has been rendered after creation */
+    ContextEvent["ContextFirstFrameRendered"] = "ContextFirstFrameRendered";
+    /** Called when the context has been destroyed */
+    ContextEvent["ContextDestroyed"] = "ContextDestroyed";
+    /** Called when the context could not find a camera during creation */
+    ContextEvent["MissingCamera"] = "MissingCamera";
+    /** Called before the context is being cleared (all objects in the scene are being destroyed and state is reset) */
+    ContextEvent["ContextClearing"] = "ContextClearing";
+    /** Called after the context has been cleared (all objects in the scene have been destroyed and state has been reset) */
+    ContextEvent["ContextCleared"] = "ContextCleared";
+})(ContextEvent || (ContextEvent = {}));
+/** Use to register to various Needle Engine context events and to get access to all current instances
+ * e.g. when being created in the DOM
+ * */
+export class ContextRegistry {
+    /** The currently active (rendering) Needle Engine context */
+    static get Current() {
+        return globalThis["NeedleEngine.Context.Current"];
+    }
+    /** @internal */
+    static set Current(ctx) {
+        globalThis["NeedleEngine.Context.Current"] = ctx;
+    }
+    /** Returns the array of all registered Needle Engine contexts. Do not modify */
+    static get All() {
+        return this.Registered;
+    }
+    /** All currently registered Needle Engine contexts. Do not modify */
+    static Registered = [];
+    /** @internal Internal use only */
+    static register(ctx) {
+        this.Registered.push(ctx);
+        this.dispatchCallback(ContextEvent.ContextRegistered, ctx);
+    }
+    /** @internal Internal use only */
+    static unregister(ctx) {
+        const index = this.Registered.indexOf(ctx);
+        if (index === -1)
+            return;
+        this.Registered.splice(index, 1);
+    }
+    static _callbacks = {};
+    static registerCallback(evt, callback) {
+        if (!this._callbacks[evt])
+            this._callbacks[evt] = [];
+        this._callbacks[evt].push(callback);
+    }
+    static unregisterCallback(evt, callback) {
+        if (!this._callbacks[evt])
+            return;
+        const index = this._callbacks[evt].indexOf(callback);
+        if (index === -1)
+            return;
+        this._callbacks[evt].splice(index, 1);
+    }
+    /** @internal */
+    static dispatchCallback(evt, context, extras) {
+        if (!this._callbacks[evt])
+            return true;
+        const cbArgs = { event: evt, context };
+        if (extras) {
+            for (const key in extras) {
+                cbArgs[key] = extras[key];
+            }
+        }
+        const promises = new Array();
+        this._callbacks[evt].forEach(cb => {
+            const res = cb(cbArgs);
+            if (res instanceof Promise)
+                promises.push(res);
+        });
+        return Promise.all(promises);
+    }
+    static addContextCreatedCallback(callback) {
+        this.registerCallback(ContextEvent.ContextCreated, callback);
+    }
+    static addContextDestroyedCallback(callback) {
+        this.registerCallback(ContextEvent.ContextDestroyed, callback);
+    }
+}
+export { ContextRegistry as NeedleEngine };
 //# sourceMappingURL=engine_context_registry.js.map

package/lib/engine/engine_coroutine.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "./engine_setup.js";
-export declare function WaitForSeconds(seconds: number, context?: Context | null): Generator<undefined, void, unknown>;
-export declare function WaitForFrames(frames: number): Generator<undefined, void, unknown>;
-export declare function WaitForPromise(promise: Promise<any>): Generator<undefined, void, unknown>;
+import { Context } from "./engine_setup.js";
+export declare function WaitForSeconds(seconds: number, context?: Context | null): Generator<undefined, void, unknown>;
+export declare function WaitForFrames(frames: number): Generator<undefined, void, unknown>;
+export declare function WaitForPromise(promise: Promise<any>): Generator<undefined, void, unknown>;

package/lib/engine/engine_coroutine.js

@@ -1,22 +1,22 @@
-import { Context } from "./engine_setup.js";
-export function* WaitForSeconds(seconds, context = null) {
-    const time = context ? context.time : Context.Current.time;
-    const start = time.time;
-    while (time.time - start < seconds) {
-        yield;
-    }
-}
-export function* WaitForFrames(frames) {
-    for (let i = 0; i < frames; i++) {
-        yield;
-    }
-}
-export function* WaitForPromise(promise) {
-    let isRunning = true;
-    promise.then(() => isRunning = false);
-    promise.catch(() => isRunning = false);
-    while (isRunning) {
-        yield;
-    }
-}
+import { Context } from "./engine_setup.js";
+export function* WaitForSeconds(seconds, context = null) {
+    const time = context ? context.time : Context.Current.time;
+    const start = time.time;
+    while (time.time - start < seconds) {
+        yield;
+    }
+}
+export function* WaitForFrames(frames) {
+    for (let i = 0; i < frames; i++) {
+        yield;
+    }
+}
+export function* WaitForPromise(promise) {
+    let isRunning = true;
+    promise.then(() => isRunning = false);
+    promise.catch(() => isRunning = false);
+    while (isRunning) {
+        yield;
+    }
+}
 //# sourceMappingURL=engine_coroutine.js.map

package/lib/engine/engine_create_objects.d.ts

@@ -1,13 +1,13 @@
-import { Mesh, Material } from "three";
-export declare enum PrimitiveType {
-    Quad = 0,
-    Cube = 1,
-    Sphere = 2
-}
-export type ObjectOptions = {
-    name?: string;
-    material?: Material;
-};
-export declare class ObjectUtils {
-    static createPrimitive(type: PrimitiveType, opts?: ObjectOptions): Mesh;
-}
+import { Mesh, Material } from "three";
+export declare enum PrimitiveType {
+    Quad = 0,
+    Cube = 1,
+    Sphere = 2
+}
+export type ObjectOptions = {
+    name?: string;
+    material?: Material;
+};
+export declare class ObjectUtils {
+    static createPrimitive(type: PrimitiveType, opts?: ObjectOptions): Mesh;
+}

package/lib/engine/engine_create_objects.js

@@ -1,34 +1,34 @@
-import { PlaneGeometry, Mesh, MeshStandardMaterial, BoxGeometry, SphereGeometry } from "three";
-export var PrimitiveType;
-(function (PrimitiveType) {
-    PrimitiveType[PrimitiveType["Quad"] = 0] = "Quad";
-    PrimitiveType[PrimitiveType["Cube"] = 1] = "Cube";
-    PrimitiveType[PrimitiveType["Sphere"] = 2] = "Sphere";
-})(PrimitiveType || (PrimitiveType = {}));
-export class ObjectUtils {
-    static createPrimitive(type, opts) {
-        let obj;
-        const color = 0xffffff;
-        switch (type) {
-            case PrimitiveType.Quad:
-                const quadGeo = new PlaneGeometry(1, 1, 1, 1);
-                const quadMat = opts?.material ?? new MeshStandardMaterial({ color: color });
-                obj = new Mesh(quadGeo, quadMat);
-                break;
-            case PrimitiveType.Cube:
-                const boxGeo = new BoxGeometry(1, 1, 1);
-                const boxMat = opts?.material ?? new MeshStandardMaterial({ color: color });
-                obj = new Mesh(boxGeo, boxMat);
-                break;
-            case PrimitiveType.Sphere:
-                const sphereGeo = new SphereGeometry(.5, 16, 16);
-                const sphereMat = opts?.material ?? new MeshStandardMaterial({ color: color });
-                obj = new Mesh(sphereGeo, sphereMat);
-                break;
-        }
-        if (opts?.name)
-            obj.name = opts.name;
-        return obj;
-    }
-}
+import { PlaneGeometry, Mesh, MeshStandardMaterial, BoxGeometry, SphereGeometry } from "three";
+export var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType[PrimitiveType["Quad"] = 0] = "Quad";
+    PrimitiveType[PrimitiveType["Cube"] = 1] = "Cube";
+    PrimitiveType[PrimitiveType["Sphere"] = 2] = "Sphere";
+})(PrimitiveType || (PrimitiveType = {}));
+export class ObjectUtils {
+    static createPrimitive(type, opts) {
+        let obj;
+        const color = 0xffffff;
+        switch (type) {
+            case PrimitiveType.Quad:
+                const quadGeo = new PlaneGeometry(1, 1, 1, 1);
+                const quadMat = opts?.material ?? new MeshStandardMaterial({ color: color });
+                obj = new Mesh(quadGeo, quadMat);
+                break;
+            case PrimitiveType.Cube:
+                const boxGeo = new BoxGeometry(1, 1, 1);
+                const boxMat = opts?.material ?? new MeshStandardMaterial({ color: color });
+                obj = new Mesh(boxGeo, boxMat);
+                break;
+            case PrimitiveType.Sphere:
+                const sphereGeo = new SphereGeometry(.5, 16, 16);
+                const sphereMat = opts?.material ?? new MeshStandardMaterial({ color: color });
+                obj = new Mesh(sphereGeo, sphereMat);
+                break;
+        }
+        if (opts?.name)
+            obj.name = opts.name;
+        return obj;
+    }
+}
 //# sourceMappingURL=engine_create_objects.js.map

package/lib/engine/engine_default_parameters.d.ts

@@ -1,2 +1,2 @@
-export declare const showGizmos: string | number | boolean;
-export declare const debugExtension: string | number | boolean;
+export declare const showGizmos: string | number | boolean;
+export declare const debugExtension: string | number | boolean;

package/lib/engine/engine_default_parameters.js

@@ -1,4 +1,4 @@
-import { getParam } from "./engine_utils.js";
-export const showGizmos = getParam("gizmos");
-export const debugExtension = getParam("debugextension");
+import { getParam } from "./engine_utils.js";
+export const showGizmos = getParam("gizmos");
+export const debugExtension = getParam("debugextension");
 //# sourceMappingURL=engine_default_parameters.js.map

package/lib/engine/engine_editor-sync.d.ts

@@ -1,17 +1,17 @@
-export declare type EditorModification = {
-    guid: string;
-    propertyName: string;
-    value: any;
-};
-/** Implement to receive callbacks from @needle-tools/editor-sync package */
-export interface IEditorModification {
-    /**
-     * Called when a modification is made through the external editor (called from @needle-tools/editor-sync)
-     * @param modification The modification that was made in the external editor
-     * @returns false if you want the editor package to apply the modification. Otherwise it's expected that your code handles applying the change
-     */
-    onEditorModification(modification: EditorModification): void | undefined | boolean;
-    /** Called immediately after the modification was made through the external editor and applied by the editor-sync package */
-    onAfterEditorModification?(mod: EditorModification): void;
-}
-export declare function getEditorModificationCache(): Map<string, EditorModification> | null | undefined;
+export declare type EditorModification = {
+    guid: string;
+    propertyName: string;
+    value: any;
+};
+/** Implement to receive callbacks from @needle-tools/editor-sync package */
+export interface IEditorModification {
+    /**
+     * Called when a modification is made through the external editor (called from @needle-tools/editor-sync)
+     * @param modification The modification that was made in the external editor
+     * @returns false if you want the editor package to apply the modification. Otherwise it's expected that your code handles applying the change
+     */
+    onEditorModification(modification: EditorModification): void | undefined | boolean;
+    /** Called immediately after the modification was made through the external editor and applied by the editor-sync package */
+    onAfterEditorModification?(mod: EditorModification): void;
+}
+export declare function getEditorModificationCache(): Map<string, EditorModification> | null | undefined;

package/lib/engine/engine_editor-sync.js

@@ -1,8 +1,8 @@
-// let editorCache = new Map<string, EditorModification>();
-// export function setEditorModificationCache(cache: Map<string, EditorModification>) {
-//     cache = editorCache;
-// }
-export function getEditorModificationCache() {
-    return globalThis["NeedleEditorSync.ModificationCache"];
-}
+// let editorCache = new Map<string, EditorModification>();
+// export function setEditorModificationCache(cache: Map<string, EditorModification>) {
+//     cache = editorCache;
+// }
+export function getEditorModificationCache() {
+    return globalThis["NeedleEditorSync.ModificationCache"];
+}
 //# sourceMappingURL=engine_editor-sync.js.map

package/lib/engine/engine_element.d.ts

@@ -1,55 +1,55 @@
-/// <reference types="webxr" />
-import { Context } from "./engine_setup.js";
-import { type INeedleEngineComponent } from "./engine_types.js";
-/** <needle-engine> web component. See @type {NeedleEngineAttributes} attributes for supported attributes
- * @type {import ("./engine_element_attributes.js").NeedleEngineAttributes}
-*/
-export declare class NeedleEngineHTMLElement extends HTMLElement implements INeedleEngineComponent {
-    static get observedAttributes(): string[];
-    get loadingProgress01(): number;
-    get loadingFinished(): boolean;
-    get cameraControls(): boolean;
-    getContext(): Promise<Context>;
-    get context(): Context;
-    /**@obsolete use context */
-    get Context(): Context;
-    /**@obsolete use Needle.GameObject */
-    private gameObject;
-    /**@obsolete use Needle.GameObject */
-    private GameObject;
-    private _context;
-    private _overlay_ar;
-    private _loadingProgress01;
-    private _loadingView?;
-    private _previousSrc;
-    /** set to true after <needle-engine> did load completely at least once. Set to false when <needle-engine> is removed from the document */
-    private _didFullyLoad;
-    constructor();
-    connectedCallback(): Promise<void>;
-    disconnectedCallback(): void;
-    attributeChangedCallback(name: string, _oldValue: string, newValue: string): void;
-    private _loadId;
-    private _lastSourceFiles;
-    private onLoad;
-    /** called by the context when the first frame has been rendered */
-    private onReady;
-    private onError;
-    private internalSetLoadingMessage;
-    private getSourceFiles;
-    private checkIfSourceHasChanged;
-    private _previouslyRegisteredMap;
-    private ensureLoadStartIsRegistered;
-    private registerEventFromAttribute;
-    getAROverlayContainer(): HTMLElement;
-    getVROverlayContainer(): HTMLElement | null;
-    onEnterAR(session: XRSession, overlayContainer: HTMLElement): void;
-    onExitAR(session: XRSession): void;
-    onEnterVR(session: XRSession): void;
-    onExitVR(session: XRSession): void;
-    private onSetupAR;
-    private onSetupVR;
-    private onSetupDesktop;
-    private setupElementsForMode;
-    private foreachHtmlElement;
-    private onBeforeBeginLoading;
-}
+/// <reference types="webxr" />
+import { Context } from "./engine_setup.js";
+import { type INeedleEngineComponent } from "./engine_types.js";
+/** <needle-engine> web component. See @type {NeedleEngineAttributes} attributes for supported attributes
+ * @type {import ("./engine_element_attributes.js").NeedleEngineAttributes}
+*/
+export declare class NeedleEngineHTMLElement extends HTMLElement implements INeedleEngineComponent {
+    static get observedAttributes(): string[];
+    get loadingProgress01(): number;
+    get loadingFinished(): boolean;
+    get cameraControls(): boolean;
+    getContext(): Promise<Context>;
+    get context(): Context;
+    /**@obsolete use context */
+    get Context(): Context;
+    /**@obsolete use Needle.GameObject */
+    private gameObject;
+    /**@obsolete use Needle.GameObject */
+    private GameObject;
+    private _context;
+    private _overlay_ar;
+    private _loadingProgress01;
+    private _loadingView?;
+    private _previousSrc;
+    /** set to true after <needle-engine> did load completely at least once. Set to false when <needle-engine> is removed from the document */
+    private _didFullyLoad;
+    constructor();
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _oldValue: string, newValue: string): void;
+    private _loadId;
+    private _lastSourceFiles;
+    private onLoad;
+    /** called by the context when the first frame has been rendered */
+    private onReady;
+    private onError;
+    private internalSetLoadingMessage;
+    private getSourceFiles;
+    private checkIfSourceHasChanged;
+    private _previouslyRegisteredMap;
+    private ensureLoadStartIsRegistered;
+    private registerEventFromAttribute;
+    getAROverlayContainer(): HTMLElement;
+    getVROverlayContainer(): HTMLElement | null;
+    onEnterAR(session: XRSession, overlayContainer: HTMLElement): void;
+    onExitAR(session: XRSession): void;
+    onEnterVR(session: XRSession): void;
+    onExitVR(session: XRSession): void;
+    private onSetupAR;
+    private onSetupVR;
+    private onSetupDesktop;
+    private setupElementsForMode;
+    private foreachHtmlElement;
+    private onBeforeBeginLoading;
+}