playcanvas/build/playcanvas/src/framework/xr/xr-anchors.js

Open-source WebGL/WebGPU 3D engine for the web

import { EventHandler } from "../../core/event-handler.js";
import { platform } from "../../core/platform.js";
import { XrAnchor } from "./xr-anchor.js";
class XrAnchors extends EventHandler {
	static EVENT_AVAILABLE = "available";
	static EVENT_UNAVAILABLE = "unavailable";
	static EVENT_ERROR = "error";
	static EVENT_ADD = "add";
	static EVENT_DESTROY = "destroy";
	manager;
	_supported = platform.browser && !!window.XRAnchor;
	_available = false;
	_checkingAvailability = false;
	_persistence = platform.browser && !!window?.XRSession?.prototype.restorePersistentAnchor;
	_creationQueue = [];
	_index = /* @__PURE__ */ new Map();
	_indexByUuid = /* @__PURE__ */ new Map();
	_list = [];
	_callbacksAnchors = /* @__PURE__ */ new Map();
	constructor(manager) {
		super();
		this.manager = manager;
		if (this._supported) {
			this.manager.on("start", this._onSessionStart, this);
			this.manager.on("end", this._onSessionEnd, this);
		}
	}
	_onSessionStart() {
		const available = this.manager.session.enabledFeatures?.indexOf("anchors") >= 0;
		if (!available) return;
		this._available = available;
		this.fire("available");
	}
	_onSessionEnd() {
		if (!this._available) return;
		this._available = false;
		for (let i2 = 0; i2 < this._creationQueue.length; i2++) {
			if (!this._creationQueue[i2].callback) {
				continue;
			}
			this._creationQueue[i2].callback(new Error("session ended"), null);
		}
		this._creationQueue.length = 0;
		this._index.clear();
		this._indexByUuid.clear();
		let i = this._list.length;
		while (i--) {
			this._list[i].destroy();
		}
		this._list.length = 0;
		this.fire("unavailable");
	}
	_createAnchor(xrAnchor, uuid = null) {
		const anchor = new XrAnchor(this, xrAnchor, uuid);
		this._index.set(xrAnchor, anchor);
		if (uuid) this._indexByUuid.set(uuid, anchor);
		this._list.push(anchor);
		anchor.once("destroy", this._onAnchorDestroy, this);
		return anchor;
	}
	_onAnchorDestroy(xrAnchor, anchor) {
		this._index.delete(xrAnchor);
		if (anchor.uuid) this._indexByUuid.delete(anchor.uuid);
		const ind = this._list.indexOf(anchor);
		if (ind !== -1) this._list.splice(ind, 1);
		this.fire("destroy", anchor);
	}
	create(position, rotation, callback) {
		if (!this._available) {
			callback?.(new Error("Anchors API is not available"), null);
			return;
		}
		if (window.XRHitTestResult && position instanceof XRHitTestResult) {
			const hitResult = position;
			callback = rotation;
			if (!this._supported) {
				callback?.(new Error("Anchors API is not supported"), null);
				return;
			}
			if (!hitResult.createAnchor) {
				callback?.(new Error("Creating Anchor from Hit Test is not supported"), null);
				return;
			}
			hitResult.createAnchor().then((xrAnchor) => {
				const anchor = this._createAnchor(xrAnchor);
				callback?.(null, anchor);
				this.fire("add", anchor);
			}).catch((ex) => {
				callback?.(ex, null);
				this.fire("error", ex);
			});
		} else {
			this._creationQueue.push({
				transform: new XRRigidTransform(position, rotation),
				callback
			});
		}
	}
	restore(uuid, callback) {
		if (!this._available) {
			callback?.(new Error("Anchors API is not available"), null);
			return;
		}
		if (!this._persistence) {
			callback?.(new Error("Anchor Persistence is not supported"), null);
			return;
		}
		if (!this.manager.active) {
			callback?.(new Error("WebXR session is not active"), null);
			return;
		}
		this.manager.session.restorePersistentAnchor(uuid).then((xrAnchor) => {
			const anchor = this._createAnchor(xrAnchor, uuid);
			callback?.(null, anchor);
			this.fire("add", anchor);
		}).catch((ex) => {
			callback?.(ex, null);
			this.fire("error", ex);
		});
	}
	forget(uuid, callback) {
		if (!this._available) {
			callback?.(new Error("Anchors API is not available"));
			return;
		}
		if (!this._persistence) {
			callback?.(new Error("Anchor Persistence is not supported"));
			return;
		}
		if (!this.manager.active) {
			callback?.(new Error("WebXR session is not active"));
			return;
		}
		this.manager.session.deletePersistentAnchor(uuid).then(() => {
			callback?.(null);
		}).catch((ex) => {
			callback?.(ex);
			this.fire("error", ex);
		});
	}
	update(frame) {
		if (!this._available) {
			if (!this.manager.session.enabledFeatures && !this._checkingAvailability) {
				this._checkingAvailability = true;
				frame.createAnchor(new XRRigidTransform(), this.manager._referenceSpace).then((xrAnchor) => {
					xrAnchor.delete();
					if (this.manager.active) {
						this._available = true;
						this.fire("available");
					}
				}).catch(() => {
				});
			}
			return;
		}
		if (this._creationQueue.length) {
			for (let i = 0; i < this._creationQueue.length; i++) {
				const request = this._creationQueue[i];
				frame.createAnchor(request.transform, this.manager._referenceSpace).then((xrAnchor) => {
					if (request.callback) {
						this._callbacksAnchors.set(xrAnchor, request.callback);
					}
				}).catch((ex) => {
					if (request.callback) {
						request.callback(ex, null);
					}
					this.fire("error", ex);
				});
			}
			this._creationQueue.length = 0;
		}
		for (const [xrAnchor, anchor] of this._index) {
			if (frame.trackedAnchors.has(xrAnchor)) {
				continue;
			}
			this._index.delete(xrAnchor);
			anchor.destroy();
		}
		for (let i = 0; i < this._list.length; i++) {
			this._list[i].update(frame);
		}
		for (const xrAnchor of frame.trackedAnchors) {
			if (this._index.has(xrAnchor)) {
				continue;
			}
			try {
				const tmp = xrAnchor.anchorSpace;
			} catch (ex) {
				continue;
			}
			const anchor = this._createAnchor(xrAnchor);
			anchor.update(frame);
			const callback = this._callbacksAnchors.get(xrAnchor);
			if (callback) {
				this._callbacksAnchors.delete(xrAnchor);
				callback(null, anchor);
			}
			this.fire("add", anchor);
		}
	}
	get supported() {
		return this._supported;
	}
	get available() {
		return this._available;
	}
	get persistence() {
		return this._persistence;
	}
	get uuids() {
		if (!this._available) {
			return null;
		}
		if (!this._persistence) {
			return null;
		}
		if (!this.manager.active) {
			return null;
		}
		return this.manager.session.persistentAnchors;
	}
	get list() {
		return this._list;
	}
}
export {
	XrAnchors
};