Raanan Weber 5 rokov pred
rodič
commit
f640283c6c

+ 4 - 4
src/Cameras/XR/features/WebXRAnchorSystem.ts

@@ -6,7 +6,7 @@ import { TransformNode } from '../../../Meshes/transformNode';
 import { Space } from '../../../Maths/math.axis';
 import { WebXRPlaneDetector } from './WebXRPlaneDetector';
 import { Nullable } from '../../../types';
-import { WebXRHitTest } from './WebXRHitTest';
+import { WebXRHitTestLegacy } from './WebXRHitTestLegacy';
 
 const Name = "xr-anchor-system";
 //register the plugin
@@ -38,7 +38,7 @@ export class WebXRAnchorSystem implements WebXRFeature {
     public onAnchorRemovedObservable: Observable<WebXRAnchor> = new Observable();
 
     private _planeDetector: WebXRPlaneDetector;
-    private _hitTestModule: WebXRHitTest;
+    private _hitTestModule: WebXRHitTestLegacy;
 
     private _enabled: boolean = false;
     private _attached: boolean = false;
@@ -54,7 +54,7 @@ export class WebXRAnchorSystem implements WebXRFeature {
         this.options.usePlaneDetection = enable;
     }
 
-    public setHitTestModule(hitTestModule: WebXRHitTest) {
+    public setHitTestModule(hitTestModule: WebXRHitTestLegacy) {
         this._hitTestModule = hitTestModule;
     }
 
@@ -139,7 +139,7 @@ export class WebXRAnchorSystem implements WebXRFeature {
         if (this._hitTestModule && !this._hitTestModule.options.testOnPointerDownOnly) {
             onResults(this._hitTestModule.lastNativeXRHitResults);
         }
-        WebXRHitTest.XRHitTestWithSelectEvent(event, this.xrSessionManager.referenceSpace).then(onResults);
+        WebXRHitTestLegacy.XRHitTestWithSelectEvent(event, this.xrSessionManager.referenceSpace).then(onResults);
 
         // API will soon change, will need to use the plane
         this._planeDetector;

+ 12 - 11
src/Cameras/XR/features/WebXRHitTest.ts

@@ -6,10 +6,6 @@ import { TransformNode } from '../../../Meshes/transformNode';
 import { Nullable } from '../../../types';
 
 const Name = "xr-hit-test";
-//register the plugin
-WebXRFeaturesManager.AddWebXRFeature(Name, (xrSessionManager, options) => {
-    return () => new WebXRHitTest(xrSessionManager, options);
-});
 
 export interface WebXRHitTestOptions {
     testOnPointerDownOnly?: boolean;
@@ -23,9 +19,10 @@ export interface WebXRHitResult {
 
 export type WebXRHitResults = WebXRHitResult[];
 
-export class WebXRHitTest implements WebXRFeature {
+export class WebXRHitTestLegacy implements WebXRFeature {
 
     public static readonly Name = Name;
+    public static readonly Version = 1;
 
     public static XRHitTestWithSelectEvent(event: XRInputSourceEvent, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]> {
         let targetRayPose = event.frame.getPose(event.inputSource.targetRaySpace, referenceSpace);
@@ -46,9 +43,7 @@ export class WebXRHitTest implements WebXRFeature {
 
     public onHitTestResultObservable: Observable<WebXRHitResults> = new Observable();
 
-    constructor(private xrSessionManager: WebXRSessionManager, public readonly options: WebXRHitTestOptions = {}) {
-
-    }
+    constructor(private xrSessionManager: WebXRSessionManager, public readonly options: WebXRHitTestOptions = {}) { }
 
     private _onSelectEnabled = false;
     private _xrFrameObserver: Nullable<Observer<XRFrame>>;
@@ -81,13 +76,14 @@ export class WebXRHitTest implements WebXRFeature {
                 direction.normalize();
                 let ray = new XRRay((<DOMPointReadOnly>{ x: origin.x, y: origin.y, z: origin.z, w: 0 }),
                     (<DOMPointReadOnly>{ x: direction.x, y: direction.y, z: direction.z, w: 0 }));
-                WebXRHitTest.XRHitTestWithRay(this.xrSessionManager.session, ray, this.xrSessionManager.referenceSpace).then(this.onHitTestResults);
+                WebXRHitTestLegacy.XRHitTestWithRay(this.xrSessionManager.session, ray, this.xrSessionManager.referenceSpace).then(this.onHitTestResults);
             });
         }
         this._attached = true;
 
         return true;
     }
+
     detach(): boolean {
         // disable select
         this._onSelectEnabled = false;
@@ -125,11 +121,16 @@ export class WebXRHitTest implements WebXRFeature {
         if (!this._onSelectEnabled) {
             return;
         }
-        WebXRHitTest.XRHitTestWithSelectEvent(event, this.xrSessionManager.referenceSpace);
+        WebXRHitTestLegacy.XRHitTestWithSelectEvent(event, this.xrSessionManager.referenceSpace);
     }
 
     dispose(): void {
         this.detach();
         this.onHitTestResultObservable.clear();
     }
-}
+}
+
+//register the plugin versions
+WebXRFeaturesManager.AddWebXRFeature(WebXRHitTestLegacy.Name, (xrSessionManager, options) => {
+    return () => new WebXRHitTestLegacy(xrSessionManager, options);
+}, WebXRHitTestLegacy.Version);

+ 1 - 1
src/Cameras/XR/features/index.ts

@@ -1,4 +1,4 @@
-export * from "./WebXRHitTest";
+export * from "./WebXRHitTestLegacy";
 export * from "./WebXRAnchorSystem";
 export * from "./WebXRPlaneDetector";
 export * from "./WebXRBackgroundRemover";

+ 4 - 4
src/Cameras/XR/webXRFeaturesManager.ts

@@ -12,8 +12,8 @@ export class WebXRFeaturesManager implements IDisposable {
 
     private static readonly _AvailableFeatures: { [name: string]: WebXRFeatureConstructor } = {};
 
-    public static AddWebXRFeature(featureName: string, constructorFunction: WebXRFeatureConstructor) {
-        this._AvailableFeatures[featureName] = constructorFunction;
+    public static AddWebXRFeature(featureName: string, constructorFunction: WebXRFeatureConstructor, version: number = 1) {
+        this._AvailableFeatures[`${featureName}-${version}`] = constructorFunction;
     }
 
     public static ConstructFeature(featureName: string, xrSessionManager: WebXRSessionManager, options?: any) {
@@ -59,11 +59,11 @@ export class WebXRFeaturesManager implements IDisposable {
         });
     }
 
-    public enableFeature(featureName: string | { Name: string }, options: any = {}, attachIfPossible: boolean = true): WebXRFeature {
+    public enableFeature(featureName: string | { Name: string }, version: number = 1, moduleOptions: any = {}, attachIfPossible: boolean = true): WebXRFeature {
         const name = typeof featureName === 'string' ? featureName : featureName.Name;
         const feature = this.features[name];
         if (!feature || !feature.featureImplementation) {
-            const constructFunction = WebXRFeaturesManager.ConstructFeature(name, this.xrSessionManager, options);
+            const constructFunction = WebXRFeaturesManager.ConstructFeature(name, this.xrSessionManager, moduleOptions);
             if (!constructFunction) {
                 // report error?
                 throw new Error(`feature not found - ${name}`);