@onerjs/core 8.55.8 → 8.56.1

package/Engines/engine.d.ts

@@ -440,6 +440,8 @@ interface XRInputSource {
     readonly gamepad?: Gamepad | undefined;
     readonly profiles: string[];
     readonly hand?: XRHand;
+    /** Indicates that the user agent recommends omitting the application's input source representation. */
+    readonly skipRendering?: boolean;
 }
 
 abstract class XRInputSource implements XRInputSource {}
@@ -631,6 +633,7 @@ interface XRSession extends EventTarget {
     readonly visibilityState: XRVisibilityState;
     readonly frameRate?: number | undefined;
     readonly supportedFrameRates?: Float32Array | undefined;
+    readonly maxRenderLayers?: number | undefined;
 
     /**
      * Removes a callback from the animation frame painting callback from
@@ -726,8 +729,8 @@ interface XRView {
     readonly eye: XREye;
     readonly projectionMatrix: Float32Array;
     readonly transform: XRRigidTransform;
-    readonly recommendedViewportScale?: number | undefined;
-    requestViewportScale(scale: number): void;
+    readonly recommendedViewportScale?: number | null | undefined;
+    requestViewportScale(scale: number | null): void;
 }
 
 abstract class XRView implements XRView {}
@@ -753,11 +756,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 +853,7 @@ interface XRPlane {
     planeSpace: XRSpace;
     polygon: DOMPointReadOnly[];
     lastChangedTime: number;
+    semanticLabel?: string | null;
 }
 
 abstract class XRPlane implements XRPlane {}
@@ -999,8 +1010,11 @@ interface XRCompositionLayer extends XRLayer {
     readonly layout: XRLayerLayout;
     blendTextureSourceAlpha: boolean;
     chromaticAberrationCorrection?: boolean | undefined;
+    forceMonoPresentation?: boolean | undefined;
+    opacity?: number | undefined;
     readonly mipLevels: number;
     readonly needsRedraw: boolean;
+    quality?: XRLayerQuality | undefined;
     destroy(): void;
 
     space: XRSpace;
@@ -1026,6 +1040,8 @@ type XRTextureType = "texture" | "texture-array";
 
 type XRLayerLayout = "default" | "mono" | "stereo" | "stereo-left-right" | "stereo-top-bottom";
 
+type XRLayerQuality = "default" | "text-optimized" | "graphics-optimized";
+
 interface XRProjectionLayerInit {
     scaleFactor?: number | undefined;
     textureType?: XRTextureType | undefined;
@@ -1039,7 +1055,7 @@ interface XRProjectionLayer extends XRCompositionLayer {
     readonly textureHeight: number;
     readonly textureArrayLength: number;
     readonly ignoreDepthValues: number;
-    fixedFoveation: number;
+    fixedFoveation?: number | null | undefined;
 }
 
 abstract class XRProjectionLayer implements XRProjectionLayer {}
@@ -1064,7 +1080,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 +1467,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.