@onerjs/core 8.55.8 → 8.55.9

package/Engines/engine.d.ts

@@ -753,11 +753,18 @@ type XRAnchorSet = Set<XRAnchor>;
 
 interface XRAnchor {
     anchorSpace: XRSpace;
+    requestPersistentHandle?: () => Promise<string>;
     delete(): void;
 }
 
 abstract class XRAnchor implements XRAnchor {}
 
+interface XRSession {
+    readonly persistentAnchors?: ReadonlyArray<string>;
+    restorePersistentAnchor?: (uuid: string) => Promise<XRAnchor>;
+    deletePersistentAnchor?: (uuid: string) => Promise<void>;
+}
+
 interface XRFrame {
     trackedAnchors?: XRAnchorSet | undefined;
     createAnchor?: (pose: XRRigidTransform, space: XRSpace) => Promise<XRAnchor>;
@@ -843,6 +850,7 @@ interface XRPlane {
     planeSpace: XRSpace;
     polygon: DOMPointReadOnly[];
     lastChangedTime: number;
+    semanticLabel?: string | null;
 }
 
 abstract class XRPlane implements XRPlane {}
@@ -1064,7 +1072,7 @@ interface XRMediaLayerInit {
 
 interface XRCylinderLayerInit extends XRLayerInit {
     textureType?: XRTextureType | undefined;
-    transform: XRRigidTransform;
+    transform?: XRRigidTransform | undefined;
     radius?: number | undefined;
     centralAngle?: number | undefined;
     aspectRatio?: number | undefined;
@@ -1451,6 +1459,7 @@ interface XRMesh {
     vertices: Float32Array;
     indices: Uint32Array;
     lastChangedTime: DOMHighResTimeStamp;
+    semanticLabel?: string | null;
 }
 
 type XRMeshSet = Set<XRMesh>;

package/Engines/thinNativeEngine.pure.d.ts

@@ -78,6 +78,11 @@ export declare class ThinNativeEngine extends ThinEngine {
     private _stencilOpStencilDepthPass;
     private _zOffset;
     private _zOffsetUnits;
+    private _cachedCulling;
+    private _cachedReverseSide;
+    private _cachedCullBackFaces;
+    private _cachedZOffset;
+    private _cachedZOffsetUnits;
     private _depthWrite;
     private _fillModeWarningDisplayed;
     constructor(options?: ThinNativeEngineOptions);
@@ -191,7 +196,7 @@ export declare class ThinNativeEngine extends ThinEngine {
     getRenderWidth(useScreen?: boolean): number;
     getRenderHeight(useScreen?: boolean): number;
     setViewport(viewport: IViewportLike, requiredWidth?: number, requiredHeight?: number): void;
-    setStateCullFaceType(_cullBackFaces?: boolean, _force?: boolean): void;
+    setStateCullFaceType(cullBackFaces?: boolean, force?: boolean): void;
     setState(culling: boolean, zOffset?: number, force?: boolean, reverseSide?: boolean, cullBackFaces?: boolean, stencil?: IStencilState, zOffsetUnits?: number): void;
     /**
      * Gets the client rect of native canvas.  Needed for InputManager.

package/Engines/thinNativeEngine.pure.js

@@ -159,6 +159,11 @@ export class ThinNativeEngine extends ThinEngine {
         this._stencilOpStencilDepthPass = 7681;
         this._zOffset = 0;
         this._zOffsetUnits = 0;
+        this._cachedCulling = true;
+        this._cachedReverseSide = false;
+        this._cachedCullBackFaces = true;
+        this._cachedZOffset = 0;
+        this._cachedZOffsetUnits = 0;
         this._depthWrite = true;
         // warning for non supported fill mode has already been displayed
         this._fillModeWarningDisplayed = false;
@@ -783,8 +788,24 @@ export class ThinNativeEngine extends ThinEngine {
         this._commandBufferEncoder.encodeCommandArgAsFloat32(viewport.height);
         this._commandBufferEncoder.finishEncodingCommand();
     }
-    setStateCullFaceType(_cullBackFaces, _force) {
-        throw new Error("setStateCullFaceType: Not Implemented");
+    setStateCullFaceType(cullBackFaces, force) {
+        const cullBack = this.cullBackFaces ?? cullBackFaces ?? true;
+        if (this._cachedCullBackFaces === cullBack && !force) {
+            return;
+        }
+        this._cachedCullBackFaces = cullBack;
+        // Native uses an immediate command-buffer state model (no lazy _depthCullingState), so
+        // re-issue the last COMMAND_SETSTATE payload with only the cull face changed. The zOffset
+        // values are the ones that command actually encoded rather than the live _zOffset fields,
+        // which setZOffset()/setZOffsetUnits() can update independently (and encode with the
+        // opposite sign under a reverse depth buffer).
+        this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_SETSTATE);
+        this._commandBufferEncoder.encodeCommandArgAsUInt32(this._cachedCulling ? 1 : 0);
+        this._commandBufferEncoder.encodeCommandArgAsFloat32(this._cachedZOffset);
+        this._commandBufferEncoder.encodeCommandArgAsFloat32(this._cachedZOffsetUnits);
+        this._commandBufferEncoder.encodeCommandArgAsUInt32(cullBack ? 1 : 0);
+        this._commandBufferEncoder.encodeCommandArgAsUInt32(this._cachedReverseSide ? 1 : 0);
+        this._commandBufferEncoder.finishEncodingCommand();
     }
     setState(culling, zOffset = 0, force, reverseSide = false, cullBackFaces, stencil, zOffsetUnits = 0) {
         this._zOffset = zOffset;
@@ -799,6 +820,12 @@ export class ThinNativeEngine extends ThinEngine {
         this._commandBufferEncoder.encodeCommandArgAsUInt32((this.cullBackFaces ?? cullBackFaces ?? true) ? 1 : 0);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(reverseSide ? 1 : 0);
         this._commandBufferEncoder.finishEncodingCommand();
+        // Cache the resolved state so setStateCullFaceType() can re-issue it with a new cull face.
+        this._cachedCulling = culling;
+        this._cachedReverseSide = reverseSide;
+        this._cachedCullBackFaces = this.cullBackFaces ?? cullBackFaces ?? true;
+        this._cachedZOffset = zOffset;
+        this._cachedZOffsetUnits = zOffsetUnits;
     }
     /**
      * Gets the client rect of native canvas.  Needed for InputManager.