@needle-tools/engine 3.0.1-alpha.4 → 3.1.0-alpha

package/src/engine-components/WebXR.ts

@@ -47,6 +47,7 @@ export enum WebXREvent {
     XRStopped = "xrStopped",
     XRUpdate = "xrUpdate",
     RequestVRSession = "requestVRSession",
+    ModifyAROptions = "modify-ar-options",
 }
 
 export declare type CreateButtonOptions = {
@@ -91,6 +92,9 @@ export class WebXR extends Behaviour {
         this.events.removeEventListener(type, listener);
         return listener;
     }
+    private static dispatchEvent(type: string, event: any): void {
+        this.events.dispatchEvent({ type, detail: event });
+    }
 
     public static createVRButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement | HTMLAnchorElement {
         if (!WebXR.XRSupported) {
@@ -122,7 +126,7 @@ export class WebXR extends Behaviour {
             console.warn("No dom overlay root found, HTML overlays on top of screen-based AR will not work.");
         }
 
-        const arButton = ARButton.createButton(webXR.context.renderer, options);
+        const arButton = ARButton.createButton(webXR.context.renderer, options, this.onModifyAROptions.bind(this));
         arButton.classList.add('webxr-ar-button');
         arButton.classList.add('webxr-button');
         WebXR.resetButtonStyles(arButton);
@@ -131,6 +135,10 @@ export class WebXR extends Behaviour {
         return arButton;
     }
 
+    private static onModifyAROptions(options){
+        WebXR.dispatchEvent(WebXREvent.ModifyAROptions, options);
+    }
+
     public static resetButtonStyles(button) {
         if (!button) return;
         button.style.position = "";
@@ -233,7 +241,8 @@ export class WebXR extends Behaviour {
         this.context.domElement.append(buttonsContainer);
 
         // AR support
-        if (this.enableAR && this.createARButton && arSupported) {
+        // if (this.enableAR && this.createARButton && arSupported) 
+        {
             arButton = WebXR.createARButton(this);
             this._arButton = arButton;
             buttonsContainer.appendChild(arButton);

package/src/engine-components/WebXRController.ts

@@ -8,7 +8,7 @@ import { InstancingUtil } from "../engine/engine_instancing";
 import { Mathf } from "../engine/engine_math";
 import { RaycastOptions } from "../engine/engine_physics";
 import { getWorldPosition, getWorldQuaternion, setWorldPosition, setWorldQuaternion } from "../engine/engine_three_utils";
-import { getParam, getPath } from "../engine/engine_utils";
+import { getParam, resolveUrl } from "../engine/engine_utils";
 import { addDracoAndKTX2Loaders } from "../engine/engine_loaders";
 
 import { Avatar_POI } from "./avatar/Avatar_Brain_LookAt";
@@ -85,7 +85,7 @@ export class WebXRController extends Behaviour {
         const loader = new GLTFLoader();
         addDracoAndKTX2Loaders(loader, context);
         if (ctrl.webXR.handModelPath && ctrl.webXR.handModelPath !== "")
-            loader.setPath(getPath(owner.sourceId, ctrl.webXR.handModelPath));
+            loader.setPath(resolveUrl(owner.sourceId, ctrl.webXR.handModelPath));
         else
             // from XRHandMeshModel.js
             loader.setPath('https://cdn.jsdelivr.net/npm/@webxr-input-profiles/assets@1.0/dist/profiles/generic-hand/');

package/src/engine-components/WebXRImageTracking.ts

@@ -0,0 +1,192 @@
+import { WebXR } from "./WebXR";
+import { serializable } from "../engine/engine_serialization";
+import { Behaviour } from "./Component";
+import { Matrix4, Object3D, Quaternion, Vector, Vector3 } from "three";
+import { CircularBuffer, getParam } from "../engine/engine_utils";
+
+// https://github.com/immersive-web/marker-tracking/blob/main/explainer.md
+
+const debug = getParam("debugimagetracking");
+
+const _scaleTemp = new Vector3();
+
+export class WebXRTrackedImage {
+
+
+    get url(): string { return this._trackedImage.image ?? ""; }
+    get widthInMeters() { return this._trackedImage.widthInMeters ?? undefined; }
+    get bitmap(): ImageBitmap { return this._bitmap; }
+    readonly measuredSize: number;
+    readonly state: "tracked" | "emulated";
+
+    // private _matrix: Matrix4 | null = null;
+    // private get matrix(): Matrix4 {
+    //     if (!this._matrix) {
+    //         // this._matrix = WebXRTrackedImage._matrixBuffer.get();
+    //         // const matrix = this._pose.transform.matrix;
+    //         // this._matrix.fromArray(matrix);
+    //     }
+    //     return this._matrix!;
+    // }
+
+    /** Copy the image position to a vector */
+    getPosition(vec: Vector3) {
+        this.ensureTransformData();
+        vec.copy(this._position);
+        return vec;
+    }
+
+    /** Copy the image rotation to a quaternion */
+    getQuaternion(quat: Quaternion) {
+        this.ensureTransformData();
+        quat.copy(this._rotation);
+        return quat;
+    }
+
+    applyToObject(object: Object3D) {
+        this.ensureTransformData();
+        object.position.copy(this._position);
+        object.quaternion.copy(this._rotation);
+    }
+
+    // private static _matrixBuffer: CircularBuffer<Matrix4> = new CircularBuffer(() => new Matrix4(), 20);
+    private static _positionBuffer: CircularBuffer<Vector3> = new CircularBuffer(() => new Vector3(), 20);
+    private static _rotationBuffer: CircularBuffer<Quaternion> = new CircularBuffer(() => new Quaternion(), 20);
+    private _position!: Vector3;
+    private _rotation!: Quaternion;
+    private ensureTransformData() {
+        if (!this._position) {
+            this._position = WebXRTrackedImage._positionBuffer.get();
+            this._rotation = WebXRTrackedImage._rotationBuffer.get();
+            const t = this._pose.transform;
+            this._position.set(-t.position.x, t.position.y, -t.position.z);
+            this._rotation.set(-t.orientation.x, t.orientation.y, -t.orientation.z, t.orientation.w);
+        }
+    }
+
+    private readonly _trackingComponent: WebXRImageTracking;;
+    private readonly _trackedImage: WebXRImageTrackingModel;
+    private readonly _bitmap: ImageBitmap;
+    private readonly _pose: any;
+
+    constructor(context: WebXRImageTracking, trackedImage: WebXRImageTrackingModel, bitmap: ImageBitmap, measuredSize: number, state: "tracked" | "emulated", pose: any) {
+        this._trackingComponent = context;;
+        this._trackedImage = trackedImage;
+        this._bitmap = bitmap;
+        this.measuredSize = measuredSize;
+        this.state = state;
+        this._pose = pose;
+    }
+
+}
+
+declare type WebXRImageTrackingEvent = (images: WebXRImageTrackingEvent[]) => void;
+
+export class WebXRImageTrackingModel {
+
+    @serializable()
+    image?: string;
+
+    @serializable()
+    widthInMeters!: number;
+
+}
+
+export class WebXRImageTracking extends Behaviour {
+
+    @serializable(WebXRImageTrackingModel)
+    trackedImages!: WebXRImageTrackingModel[];
+
+
+
+
+    private readonly trackedImageIndexMap: Map<number, WebXRImageTrackingModel> = new Map();
+
+    private static _imageElements: Map<string, ImageBitmap | null> = new Map();
+
+    awake(): void {
+        for (const trackedImage of this.trackedImages) {
+            if (trackedImage.image) {
+                if (WebXRImageTracking._imageElements.has(trackedImage.image)) {
+                }
+                else {
+                    const url = trackedImage.image;
+                    WebXRImageTracking._imageElements.set(url, null);
+                    const imageElement = document.createElement("img") as HTMLImageElement;
+                    imageElement.src = url;
+                    imageElement.addEventListener("load", async () => {
+                        const img = await createImageBitmap(imageElement);
+                        WebXRImageTracking._imageElements.set(url, img);
+                    });
+                }
+            }
+        }
+    }
+
+    onEnable(): void {
+        WebXR.addEventListener("modify-ar-options", this.onModifyAROptions);
+    }
+
+    onDisable(): void {
+        WebXR.removeEventListener("modify-ar-options", this.onModifyAROptions);
+    }
+
+
+    private onModifyAROptions = (event: any) => {
+        const options = event.detail;
+        const features = options.optionalFeatures || [];
+        features.push("image-tracking");
+        options.optionalFeatures = features;
+
+        options.trackedImages = [];
+        for (const trackedImage of this.trackedImages) {
+            if (trackedImage.image?.length && trackedImage.widthInMeters > 0) {
+                const bitmap = WebXRImageTracking._imageElements.get(trackedImage.image);
+                if (bitmap) {
+                    this.trackedImageIndexMap.set(options.trackedImages.length, trackedImage);
+                    options.trackedImages.push({
+                        image: bitmap,
+                        widthInMeters: trackedImage.widthInMeters
+                    });
+                }
+            }
+        }
+    }
+
+    onBeforeRender(frame: XRFrame | null): void {
+        //@ts-ignore
+        if (frame?.session && typeof frame.getImageTrackingResults === "function") {
+            //@ts-ignore
+            const results = frame.getImageTrackingResults();
+            if (results.length) {
+                const space = this.context.renderer.xr.getReferenceSpace();
+                if (space) {
+                    const images: WebXRTrackedImage[] = [];
+                    for (const result of results) {
+                        const imageIndex = result.index;
+                        const trackedImage = this.trackedImageIndexMap.get(imageIndex);
+                        if (trackedImage) {
+                            const pose = frame.getPose(result.imageSpace, space);
+                            const state = result.trackingState;
+                            const imageData = new WebXRTrackedImage(this, trackedImage, result.image, result.measuredSize, state, pose);
+                            images.push(imageData);
+                        }
+                        else {
+                            if (debug) {
+                                console.warn("No tracked image for index", imageIndex);
+                            }
+                        }
+                    }
+                    if (images.length > 0) {
+                        try {
+                            this.dispatchEvent(new CustomEvent("image-tracking", { detail: images }));
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/src/engine-components/codegen/components.ts

@@ -145,6 +145,7 @@ export { TestRunner } from "../TestRunner";
 export { TestSimulateUserData } from "../TestRunner";
 export { Text } from "../ui/Text";
 export { TextureSheetAnimationModule } from "../ParticleSystemModules";
+export { TiltShiftEffect } from "../postprocessing/Effects/TiltShiftEffect";
 export { ToneMapping } from "../postprocessing/Effects/Tonemapping";
 export { TrailModule } from "../ParticleSystemModules";
 export { TransformData } from "../export/usdz/extensions/Animation";
@@ -168,7 +169,10 @@ export { WebARSessionRoot } from "../WebARSessionRoot";
 export { WebXR } from "../WebXR";
 export { WebXRAvatar } from "../WebXRAvatar";
 export { WebXRController } from "../WebXRController";
+export { WebXRImageTracking } from "../WebXRImageTracking";
+export { WebXRImageTrackingModel } from "../WebXRImageTracking";
 export { WebXRSync } from "../WebXRSync";
+export { WebXRTrackedImage } from "../WebXRImageTracking";
 export { XRFlag } from "../XRFlag";
 export { XRGrabModel } from "../WebXRGrabRendering";
 export { XRGrabRendering } from "../WebXRGrabRendering";

package/src/engine-components/postprocessing/Effects/DepthOfField.ts

@@ -1,11 +1,10 @@
 import { DepthOfFieldEffect } from "postprocessing";
-import { PerspectiveCamera, Vector3 } from "three";
-import { getWorldPosition } from "../../../engine/engine_three_utils";
 import { serializable } from "../../../engine/engine_serialization";
 import { Mathf } from "../../../engine/engine_math";
 import { PostProcessingEffect } from "../PostProcessingEffect";
 import { VolumeParameter } from "../VolumeParameter";
 import { registerCustomEffectType } from "../VolumeProfile";
+import { isMobileDevice } from "../../../engine/engine_utils";
 
 export enum DepthOfFieldMode {
     Off = 0,
@@ -20,7 +19,7 @@ export class DepthOfField extends PostProcessingEffect {
     }
 
     @serializable()
-    mode! : DepthOfFieldMode;
+    mode!: DepthOfFieldMode;
 
     @serializable(VolumeParameter)
     focusDistance!: VolumeParameter;
@@ -34,13 +33,19 @@ export class DepthOfField extends PostProcessingEffect {
     @serializable(VolumeParameter)
     gaussianMaxRadius!: VolumeParameter;
 
+    @serializable(VolumeParameter)
+    resolutionScale?: VolumeParameter;
+
+    @serializable(VolumeParameter)
+    bokehScale?: VolumeParameter;
+
     init() {
         this.focalLength.valueProcessor = v => {
             const t = v / 300;
             const max = 2;// this.context.mainCameraComponent?.farClipPlane ?? 10;
             return Mathf.lerp(max, .01, t);
         };
-        
+
         const maxBokehScale = 20;
         this.aperture.valueProcessor = v => {
             const t = 1 - v / 32;
@@ -49,7 +54,16 @@ export class DepthOfField extends PostProcessingEffect {
     }
 
     onCreateEffect() {
-        if(this.mode === DepthOfFieldMode.Off) return undefined;
+        if (this.mode === DepthOfFieldMode.Off) return undefined;
+
+        const factor = 1 / window.devicePixelRatio;
+
+        if (this.resolutionScale === undefined) {
+            let defaultValue = 1;
+            if(isMobileDevice()) defaultValue = .6;
+            this.resolutionScale = new VolumeParameter(defaultValue * factor);
+        }
+
         // console.log(this.focusDistance.overrideState, this.focusDistance.value);
         // const depth = new DepthEffect({
         //     inverted: true,
@@ -59,7 +73,7 @@ export class DepthOfField extends PostProcessingEffect {
             worldFocusRange: .2,
             focalLength: 1,
             bokehScale: 20,
-            resolutionScale: 1,
+            resolutionScale: this.resolutionScale.value,
         });
 
         this.focusDistance.onValueChanged = v => {
@@ -68,6 +82,7 @@ export class DepthOfField extends PostProcessingEffect {
         this.focalLength.onValueChanged = v => dof.circleOfConfusionMaterial.worldFocusRange = v;
         this.aperture.onValueChanged = v => dof.bokehScale = v;
 
+        if (this.resolutionScale) this.resolutionScale.onValueChanged = v => dof.resolution.scale = v;
 
         return [dof];
     }

package/src/engine-components/postprocessing/Effects/TiltShiftEffect.ts

@@ -0,0 +1,56 @@
+import { registerCustomEffectType } from "../VolumeProfile";
+import { EffectProviderResult, PostProcessingEffect } from "../PostProcessingEffect";
+import { KernelSize, TiltShiftEffect as TiltShift } from "postprocessing";
+import { VolumeParameter } from "../VolumeParameter";
+import { serializable } from "../../../engine/engine_serialization";
+
+
+export class TiltShiftEffect extends PostProcessingEffect {
+    get typeName(): string {
+        return "TiltShiftEffect";
+    }
+
+    @serializable(VolumeParameter)
+    offset!: VolumeParameter;
+    @serializable(VolumeParameter)
+    rotation!: VolumeParameter;
+    @serializable(VolumeParameter)
+    focusArea!: VolumeParameter;
+    @serializable(VolumeParameter)
+    feather!: VolumeParameter
+    @serializable(VolumeParameter)
+    kernelSize!: VolumeParameter;
+    @serializable(VolumeParameter)
+    resolutionScale!: VolumeParameter;
+
+    init(): void {
+        this.offset.defaultValue = 0;
+        this.rotation.defaultValue = 0;
+        this.focusArea.defaultValue = 0.4;
+        this.feather.defaultValue = 0.3;
+        this.kernelSize.defaultValue = KernelSize.MEDIUM;
+        this.resolutionScale.defaultValue = 1 / window.devicePixelRatio;
+    }
+
+
+    onCreateEffect(): EffectProviderResult | undefined {
+
+        console.log(this);
+
+        const effect = new TiltShift({
+            kernelSize: KernelSize.VERY_LARGE,
+        });
+        
+        this.offset.onValueChanged = v => effect.offset = v;
+        this.rotation.onValueChanged = v => effect.rotation = v;
+        this.focusArea.onValueChanged = v => effect.focusArea = v;
+        this.feather.onValueChanged = v => effect.feather = v;
+        this.kernelSize.onValueChanged = v => effect.blurPass.kernelSize = v;
+        this.resolutionScale.onValueChanged = v => effect.resolution.scale = v / window.devicePixelRatio;
+
+
+        return effect;
+    }
+
+}
+registerCustomEffectType("TiltShiftEffect", TiltShiftEffect);

package/src/engine-components/postprocessing/VolumeParameter.ts

@@ -5,6 +5,11 @@ export declare type VolumeParameterValueProcessor = (value: any) => any;
 
 export class VolumeParameter {
 
+    constructor(value?: any) {
+        this._value = value;
+        this._defaultValue = value;
+    }
+
     @serializable()
     get overrideState(): boolean {
         return this._active;

package/src/engine-components/timeline/PlayableDirector.ts

@@ -6,7 +6,7 @@ import { AudioSource } from '../AudioSource';
 import { SignalReceiver } from './SignalAsset';
 import * as Models from "./TimelineModels";
 import * as Tracks from "./TimelineTracks";
-import { deepClone, getParam } from '../../engine/engine_utils';
+import { deepClone, delay, getParam } from '../../engine/engine_utils';
 import { GuidsMap } from '../../engine/engine_types';
 import { Object3D } from 'three';
 import { isLocalNetwork } from '../../engine/engine_networking_utils';
@@ -87,6 +87,8 @@ export class PlayableDirector extends Behaviour {
     get speed(): number { return this._speed; }
     set speed(value: number) { this._speed = value; }
 
+    /** When enabled the timeline will wait for audio tracks to load at the current time before starting to play */
+    waitForAudio: boolean = true;
 
     private _visibilityChangeEvt?: any;
     private _clonedPlayableAsset: boolean = false;
@@ -151,13 +153,28 @@ export class PlayableDirector extends Behaviour {
         this.setupAndCreateTrackHandlers();
     }
 
-    play() {
+    async play() {
         if (!this.isValid()) return;
         const pauseChanged = this._isPaused == true;
         this._isPaused = false;
         if (pauseChanged) this.invokePauseChangedMethodsOnTracks();
         if (this._isPlaying) return;
         this._isPlaying = true;
+        if (this.waitForAudio) {
+            // Make sure audio tracks have loaded at the current time
+            const promises: Array<Promise<any>> = [];
+            for (const track of this._audioTracks) {
+                const promise = track.loadAudio(this._time, 1, 0);
+                if (promise)
+                    promises.push(promise);
+            }
+            if (promises.length > 0) {
+                await Promise.all(promises);
+                if (!this._isPlaying) return;
+            }
+            while(this._audioTracks.length > 0 && this._isPlaying && !AudioSource.userInteractionRegistered && this.waitForAudio) 
+                await delay(200);
+        }
         this._internalUpdateRoutine = this.startCoroutine(this.internalUpdate());
     }
 
@@ -363,6 +380,25 @@ export class PlayableDirector extends Behaviour {
                         console.warn("Missing binding", binding, track.name, track.type, this.name, this.playableAsset.name);
                 }
             }
+            if (track.type === Models.TrackType.Control) {
+                for (let i = 0; i < track.clips.length; i++) {
+                    const clip = track.clips[i];
+                    let binding = clip.asset.sourceObject;
+                    if (typeof binding === "string") {
+                        if (this._guidsMap && this._guidsMap[binding])
+                            binding = this._guidsMap[binding];
+                        const obj = GameObject.findByGuid(binding, root);
+                        if (obj === null || typeof obj !== "object") {
+                            console.warn("Failed to resolve sourceObject binding", binding, track.name, clip);
+                        }
+                        else {
+                            if (debug)
+                                console.log("Resolved binding", binding, "to", obj);
+                            clip.asset.sourceObject = obj;
+                        }
+                    }
+                }
+            }
         }
     }
 

package/src/engine-components/timeline/TimelineTracks.ts

@@ -5,7 +5,7 @@ import { GameObject } from "../Component";
 import { Context } from "../../engine/engine_setup";
 import { SignalReceiver } from "./SignalAsset";
 import { AnimationClip, Quaternion, Vector3 } from "three";
-import { getParam, getPath } from "../../engine/engine_utils";
+import { getParam, resolveUrl } from "../../engine/engine_utils";
 import { AudioSource } from "../AudioSource";
 import { Animator } from "../Animator"
 
@@ -517,7 +517,7 @@ export class AudioTrackHandler extends TrackHandler {
     private getAudioFilePath(path: string) {
         // TODO: this should be the timeline asset location probably which MIGHT be different
         const glbLocation = this.director.sourceId;
-        return getPath(glbLocation, path);
+        return resolveUrl(glbLocation, path);
     }
 
     onAllowAudioChanged(allow: boolean) {
@@ -657,6 +657,9 @@ export class AudioTrackHandler extends TrackHandler {
     }
 
     private static _currentlyLoading: Map<string, Promise<AudioBuffer | null>> = new Map();
+    public static dispose() {
+        AudioTrackHandler._currentlyLoading.clear();
+    }
     
     private handleAudioLoading(model: Models.ClipModel, audio: THREE.Audio): Promise<AudioBuffer | null> | null {
         if (!this._audioLoader) {
@@ -665,8 +668,12 @@ export class AudioTrackHandler extends TrackHandler {
         // TODO: maybe we should cache the loaders / buffers here by path
         const path = this.getAudioFilePath(model.asset.clip);
 
-        if(AudioTrackHandler._currentlyLoading.get(path)) {
-            return AudioTrackHandler._currentlyLoading.get(path)!;
+        if (AudioTrackHandler._currentlyLoading.get(path)) {
+            const promise = AudioTrackHandler._currentlyLoading.get(path)!
+            promise.then((buffer) => {
+                if (buffer) audio.setBuffer(buffer);
+            });
+            return promise;
         }
         
         if (debug) console.warn("LOAD audio track", path, this.director.sourceId);
@@ -724,23 +731,13 @@ export class ControlTrackHandler extends TrackHandler {
     models: Array<Models.ClipModel> = [];
     timelines: Array<PlayableDirector | null> = [];
 
-    private static resolved: { [key: string]: THREE.Object3D } = {};
-
-    resolveSourceObjects(context: Context) {
+    resolveSourceObjects(_context: Context) {
         for (let i = this.models.length - 1; i >= 0; i--) {
             const model = this.models[i];
             const asset = model.asset as Models.ControlClipModel;
-            if (typeof asset.sourceObject === "string") {
-                const key = asset.sourceObject;
-                if (ControlTrackHandler.resolved[key]) {
-                    asset.sourceObject = ControlTrackHandler.resolved[key];
-                }
-                else {
-                    asset.sourceObject = GameObject.findByGuid(key, context.scene) as THREE.Object3D
-                    ControlTrackHandler.resolved[key] = asset.sourceObject;
-                }
-            }
-            if (!asset.sourceObject) {
+
+            if (!asset.sourceObject || typeof asset.sourceObject !== "object") {
+                console.log("no source object, removing model", i, asset);
                 this.models.splice(i, 1);
                 continue;
             }

package/src/engine-components/ui/Text.ts

@@ -7,7 +7,7 @@ import { FrameEvent } from '../../engine/engine_setup';
 import { updateRenderSettings } from './Utils';
 import { Canvas } from './Canvas';
 import { serializable } from '../../engine/engine_serialization_decorator';
-import { getParam, getPath } from '../../engine/engine_utils';
+import { getParam, resolveUrl } from '../../engine/engine_utils';
 
 const debug = getParam("debugtext");
 
@@ -176,7 +176,6 @@ export class Text extends Graphic {
             fontSize: fontSize,
             fontKerning: "normal",
         };
-        this.font = this.font?.toLocaleLowerCase();
         this.setFont(textOpts, this.fontStyle);
         return textOpts;
     }
@@ -482,24 +481,24 @@ export class Text extends Graphic {
 
         // if a font path has a known suffix we remove it
         if (fontName.endsWith("-regular")) {
-            if (style === FontStyle.Normal) return getPath(this.sourceId, fontName);
+            if (style === FontStyle.Normal) return resolveUrl(this.sourceId, fontName);
                 fontName = fontName.substring(0, fontName.length - "-regular".length);
         }
         else if (fontName.endsWith("-bold")) {
-            if (style === FontStyle.Bold)return getPath(this.sourceId, fontName);
+            if (style === FontStyle.Bold)return resolveUrl(this.sourceId, fontName);
                 fontName = fontName.substring(0, fontName.length - "-bold".length);
         }
         else if (fontName.endsWith("-italic")) {
-            if (style === FontStyle.Italic)return getPath(this.sourceId, fontName);
+            if (style === FontStyle.Italic)return resolveUrl(this.sourceId, fontName);
                 fontName = fontName.substring(0, fontName.length - "-italic".length);
         }
         else if (fontName.endsWith("-bolditalic")) {
-            if (style === FontStyle.BoldAndItalic)return getPath(this.sourceId, fontName);
+            if (style === FontStyle.BoldAndItalic)return resolveUrl(this.sourceId, fontName);
                 fontName = fontName.substring(0, fontName.length - "-bolditalic".length);
         }
         else
             // If a font does not have a specific style suffic we dont support getting the correct font style
-            return getPath(this.sourceId, fontName);
+            return resolveUrl(this.sourceId, fontName);
 
         switch (style) {
             case FontStyle.Normal:
@@ -516,7 +515,7 @@ export class Text extends Graphic {
                 break;
         }
 
-        return getPath(this.sourceId, fontName);
+        return resolveUrl(this.sourceId, fontName);
     }
 }
 

package/src/include/three/ARButton.js

@@ -1,6 +1,6 @@
 class ARButton {
 
-	static createButton( renderer, options = {} ) {
+	static createButton( renderer, options = {}, beforeRequestSession ) {
 
 		const button = document.createElement( 'button' );
 		let ARButtonControlsDomOverlay = false;
@@ -126,7 +126,7 @@ class ARButton {
 			button.onclick = function () {
 
 				if ( currentSession === null ) {
-
+					beforeRequestSession?.call(this, options);
 					navigator.xr.requestSession( 'immersive-ar', options ).then( onSessionStarted );
 
 				} else {

package/lib/engine/codegen/license.json

@@ -1 +0,0 @@
-{}

package/license-2447137e.js

@@ -1,4 +0,0 @@
-const e = {};
-export {
-  e as default
-};

package/src/engine/codegen/license.json

@@ -1 +0,0 @@
-{}