XR editor adaptation

packages/loader/src/PrefabLoader.ts

@@ -1,16 +1,7 @@
-import {
-  AssetPromise,
-  AssetType,
-  Engine,
-  EngineConfiguration,
-  Loader,
-  LoadItem,
-  resourceLoader,
-  ResourceManager
-} from "@galacean/engine-core";
+import { AssetPromise, AssetType, Loader, LoadItem, resourceLoader, ResourceManager } from "@galacean/engine-core";
+import { PrefabParser } from "./prefab/PrefabParser";
 import { PrefabResource } from "./prefab/PrefabResource";
 import { IHierarchyFile } from "./resource-deserialize";
-import { PrefabParser } from "./prefab/PrefabParser";
 
 @resourceLoader(AssetType.Prefab, ["prefab"])
 export class PrefabLoader extends Loader<PrefabResource> {

packages/loader/src/index.ts

@@ -30,4 +30,3 @@ export { KTX2Loader, KTX2Transcoder } from "./ktx2/KTX2Loader";
 export { KTX2TargetFormat } from "./ktx2/KTX2TargetFormat";
 export * from "./resource-deserialize";
 export * from "./prefab/PrefabResource";
-export { PrefabLoader } from "./PrefabLoader";

packages/loader/src/resource-deserialize/index.ts

@@ -1,6 +1,6 @@
 import { Engine } from "@galacean/engine-core";
 import { BufferReader } from "./utils/BufferReader";
-import { decoderMap, decoder } from "./utils/Decorator";
+import { decoderMap } from "./utils/Decorator";
 import { FileHeader } from "./utils/FileHeader";
 
 export { MeshDecoder } from "./resources/mesh/MeshDecoder";
@@ -29,3 +29,7 @@ export * from "./resources/scene/SceneParser";
 export * from "./resources/scene/MeshLoader";
 export * from "./resources/scene/EditorTextureLoader";
 export * from "./resources/parser/ParserContext";
+
+export * from "./utils/BufferReader";
+export * from "./utils/Decorator";
+export * from "./utils/FileHeader";

packages/loader/src/resource-deserialize/resources/scene/SceneParser.ts

@@ -1,4 +1,4 @@
-import { Engine, ReferResource, Scene } from "@galacean/engine-core";
+import { Engine, Scene } from "@galacean/engine-core";
 import type { IScene } from "../schema";
 import { HierarchyParser } from "../parser/HierarchyParser";
 import { ParserContext, ParserType } from "../parser/ParserContext";

packages/xr-webxr/src/WebXRDevice.ts

@@ -25,7 +25,16 @@ export class WebXRDevice implements IXRDevice {
   }
 
   isSupportedFeature(type: XRFeatureType): boolean {
-    return true;
+    switch (type) {
+      case XRFeatureType.HitTest:
+      case XRFeatureType.PlaneTracking:
+        return typeof XRPlane !== "undefined";
+      case XRFeatureType.AnchorTracking:
+        return typeof XRAnchor !== "undefined";
+      case XRFeatureType.ImageTracking:
+        // @ts-ignore
+        return typeof XRImageTrackingResult !== "undefined";
+    }
   }
 
   createPlatformFeature(type: XRFeatureType, ...args: any[]): WebXRFeature {

packages/xr-webxr/src/WebXRSession.ts

@@ -140,7 +140,7 @@ export class WebXRSession implements IXRSession {
     session.removeEventListener("squeeze", onSessionEvent);
     session.removeEventListener("squeezestart", onSessionEvent);
     session.removeEventListener("squeezeend", onSessionEvent);
-    session.addEventListener("end", this._onSessionExit);
+    session.removeEventListener("end", this._onSessionExit);
     this._events.length = 0;
   }
 

packages/xr/src/XRManagerExtended.ts

@@ -20,12 +20,13 @@ export class XRManagerExtended extends XRManager {
   override sessionManager: XRSessionManager;
   /** Camera manager for XR. */
   override cameraManager: XRCameraManager;
+  /** All initialized features at this moment. */
+  readonly features: XRFeature[] = [];
 
   /** @internal */
   _platformDevice: IXRDevice;
 
   private _origin: Entity;
-  private _features: XRFeature[];
 
   /**
    * The current origin of XR space.
@@ -60,17 +61,19 @@ export class XRManagerExtended extends XRManager {
   override addFeature<T extends new (xrManager: XRManagerExtended, ...args: any[]) => XRFeature>(
     type: T,
     ...args: TFeatureConstructorArguments<T>
-  ): XRFeature | null {
+  ): InstanceType<T> | null {
     if (this.sessionManager._platformSession) {
       throw new Error("Cannot add feature when the session is initialized.");
     }
-    const { _features: features } = this;
+    if (!this._platformDevice.isSupportedFeature(XRManagerExtended._featureMap.get(type))) {
+      throw new Error("The feature is not supported");
+    }
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
-      const feature = features[i];
-      if (feature instanceof type) throw new Error("The feature has been added");
+      if (features[i] instanceof type) throw new Error("The feature has been added");
     }
-    const feature = new type(this, ...args);
-    this._features.push(feature);
+    const feature = new type(this, ...args) as InstanceType<T>;
+    features.push(feature);
     return feature;
   }
 
@@ -80,7 +83,7 @@ export class XRManagerExtended extends XRManager {
    * @returns	The feature which match type
    */
   override getFeature<T extends XRFeature>(type: TFeatureConstructor<T>): T | null {
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       if (feature instanceof type) {
@@ -89,20 +92,6 @@ export class XRManagerExtended extends XRManager {
     }
   }
 
-  override getFeatures<T extends XRFeature>(type: TFeatureConstructor<T>, out?: T[]): T[] {
-    if (out) {
-      out.length = 0;
-    } else {
-      out = [];
-    }
-    const { _features: features } = this;
-    for (let i = 0, n = features.length; i < n; i--) {
-      const feature = features[i];
-      feature instanceof type && out.push(feature);
-    }
-    return out;
-  }
-
   /**
    * Enter XR immersive mode, when you call this method, it will initialize and display the XR virtual world.
    * @param sessionMode - The mode of the session
@@ -120,8 +109,9 @@ export class XRManagerExtended extends XRManager {
     return new Promise((resolve, reject) => {
       // 1. Check if this xr mode is supported
       sessionManager.isSupportedMode(sessionMode).then(() => {
+        sessionManager.state = XRSessionState.Requesting;
         // 2. Initialize session
-        sessionManager._initialize(sessionMode, this._features).then(() => {
+        sessionManager._initialize(sessionMode, this.features).then(() => {
           autoRun && sessionManager.run();
           resolve();
         }, reject);
@@ -145,7 +135,7 @@ export class XRManagerExtended extends XRManager {
    * @internal
    */
   override _initialize(engine: Engine, xrDevice: IXRDevice): void {
-    this._features = [];
+    this.features.length = 0;
     this._platformDevice = xrDevice;
     this.sessionManager = new XRSessionManager(this, engine);
     this.inputManager = new XRInputManager(this, engine);
@@ -161,7 +151,7 @@ export class XRManagerExtended extends XRManager {
     sessionManager._onUpdate();
     this.inputManager._onUpdate();
     this.cameraManager._onUpdate();
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       feature.enabled && feature._onUpdate();
@@ -210,7 +200,7 @@ export class XRManagerExtended extends XRManager {
    * @internal
    */
   _onSessionStop(): void {
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       feature.enabled && feature._onSessionStop();
@@ -221,7 +211,7 @@ export class XRManagerExtended extends XRManager {
    * @internal
    */
   _onSessionInit(): void {
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       feature.enabled && feature._onSessionInit();
@@ -233,7 +223,7 @@ export class XRManagerExtended extends XRManager {
    */
   _onSessionStart(): void {
     this.cameraManager._onSessionStart();
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       feature.enabled && feature._onSessionStart();
@@ -245,7 +235,7 @@ export class XRManagerExtended extends XRManager {
    */
   _onSessionExit(): void {
     this.cameraManager._onSessionExit();
-    const { _features: features } = this;
+    const { features } = this;
     for (let i = 0, n = features.length; i < n; i++) {
       const feature = features[i];
       feature.enabled && feature._onSessionExit();
@@ -285,19 +275,6 @@ declare module "@galacean/engine" {
     get origin(): Entity;
     set origin(value: Entity);
 
-    /**
-     * Get all initialized features at this moment.
-     * @param type - The type of the feature
-     */
-    getFeatures<T extends XRFeature>(type: TFeatureConstructor<T>): T[];
-
-    /**
-     * Get all initialized features at this moment.
-     * @param type - The type of the feature
-     * @param out - Save all features in `out`
-     */
-    getFeatures<T extends XRFeature>(type: TFeatureConstructor<T>, out: T[]): T[];
-
     /**
      * Check if the specified feature is supported.
      * @param type - The type of the feature
@@ -314,15 +291,14 @@ declare module "@galacean/engine" {
     addFeature<T extends new (xrManager: XRManagerExtended, ...args: any[]) => XRFeature>(
       type: T,
       ...args: TFeatureConstructorArguments<T>
-    ): XRFeature | null;
+    ): InstanceType<T> | null;
 
     /**
      * Get feature which match the type.
      * @param type - The type of the feature
      * @returns	The feature which match type
      */
     getFeature<T extends XRFeature>(type: TFeatureConstructor<T>): T | null;
-    getFeatures<T extends XRFeature>(type: TFeatureConstructor<T>, out?: T[]): T[];
     /**
      * Enter XR immersive mode, when you call this method, it will initialize and display the XR virtual world.
      * @param sessionMode - The mode of the session

packages/xr/src/feature/trackable/XRTrackableFeature.ts

@@ -9,9 +9,10 @@ import { XRTracked } from "./XRTracked";
 /**
  * The base class of XR trackable manager.
  */
-export abstract class XRTrackableFeature<T extends XRTracked, K extends XRRequestTracking<T>> extends XRFeature<
-  IXRTrackablePlatformFeature<T, K>
-> {
+export abstract class XRTrackableFeature<
+  T extends XRTracked = XRTracked,
+  K extends XRRequestTracking<T> = XRRequestTracking<T>
+> extends XRFeature<IXRTrackablePlatformFeature<T, K>> {
   protected static _uuid = 0;
 
   protected _requestTrackings: K[] = [];
@@ -123,11 +124,6 @@ export abstract class XRTrackableFeature<T extends XRTracked, K extends XRReques
     this._requestTrackings.length = this._tracked.length = this._added.length = this._updated.length = this._removed.length = 0;
   }
 
-  override _onDestroy(): void {
-    // prettier-ignore
-    this._requestTrackings.length = this._tracked.length = this._added.length = this._updated.length = this._removed.length = 0;
-  }
-
   protected _addRequestTracking(requestTracking: K): void {
     const { _platformFeature: platformFeature } = this;
     if (this._xrManager.sessionManager._platformSession && !platformFeature.canModifyRequestTrackingAfterInit) {

packages/xr/src/index.ts

@@ -4,6 +4,8 @@ import "./XRManagerExtended";
 export { XRPose } from "./XRPose";
 // xr feature
 export { XRFeature } from "./feature/XRFeature";
+export { XRTrackableFeature } from "./feature/trackable/XRTrackableFeature";
+export { XRTracked } from "./feature/trackable/XRTracked";
 // camera
 export { XRCameraManager } from "./feature/camera/XRCameraManager";
 // hitTest
@@ -38,3 +40,6 @@ export { XRFeatureType } from "./feature/XRFeatureType";
 export { XRRequestTrackingState } from "./feature/trackable/XRRequestTrackingState";
 export { XRInputEventType } from "./input/XRInputEventType";
 export { XRTargetRayMode } from "./input/XRTargetRayMode";
+
+export * from "./loader/XRReferenceImageDecoder";
+export * from "./loader/XRReferenceImageLoader";

packages/xr/src/loader/XRReferenceImageDecoder.ts

@@ -0,0 +1,17 @@
+import { BufferReader, Engine, decoder } from "@galacean/engine";
+import { XRReferenceImage } from "../feature/trackable/image/XRReferenceImage";
+
+@decoder("XRReferenceImage")
+export class XRReferenceImageDecoder {
+  static decode(engine: Engine, bufferReader: BufferReader): Promise<XRReferenceImage> {
+    return new Promise((resolve, reject) => {
+      const physicalWidth = bufferReader.nextFloat32();
+      bufferReader.nextUint8();
+      const img = new Image();
+      img.onload = () => {
+        resolve(new XRReferenceImage("", img, physicalWidth));
+      };
+      img.src = URL.createObjectURL(new window.Blob([bufferReader.nextImagesData(1)[0]]));
+    });
+  }
+}

packages/xr/src/loader/XRReferenceImageLoader.ts

@@ -0,0 +1,17 @@
+import { AssetPromise, decode, Loader, LoadItem, resourceLoader, ResourceManager } from "@galacean/engine";
+import { XRReferenceImage } from "../feature/trackable/image/XRReferenceImage";
+
+@resourceLoader("XRReferenceImage", [])
+export class XRReferenceImageLoader extends Loader<XRReferenceImage> {
+  load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<XRReferenceImage> {
+    return new AssetPromise((resolve, reject) => {
+      this.request<ArrayBuffer>(item.url, { ...item, type: "arraybuffer" })
+        .then((data) => {
+          decode<XRReferenceImage>(data, resourceManager.engine).then((referenceImage) => {
+            resolve(referenceImage);
+          });
+        })
+        .catch(reject);
+    });
+  }
+}