XR / VR / AR Platforms¶

IntelliVerseX provides a unified XR abstraction layer that works across Meta Quest, SteamVR, Apple Vision Pro, and AR Foundation — without requiring any XR SDK as a hard dependency.

Supported XR Platforms¶

Setup¶

Compile Defines¶

IntelliVerseX uses compile defines to keep XR support zero-dependency. The SDK never pulls in an XR package — you add the define only after you have installed the corresponding XR SDK yourself.

Add defines in Player Settings → Other Settings → Scripting Define Symbols or in your .csproj / .asmdef:

INTELLIVERSEX_HAS_META_XR;INTELLIVERSEX_HAS_OPENXR

Per-Platform Setup¶

// IVXXRPlatformHelper auto-detection (simplified)
#if INTELLIVERSEX_HAS_META_XR
if (OVRPlugin.initialized)
{
    _activePlatform = XRPlatform.MetaQuest;
    _inputProvider = new IVXMetaXRInputProvider();
}
#endif

#if INTELLIVERSEX_HAS_OPENXR
var loader = XRGeneralSettings.Instance?.Manager?.activeLoader;
if (loader != null && loader.name.Contains("OpenXR"))
{
    _activePlatform = XRPlatform.SteamVR;
    _inputProvider = new IVXOpenXRInputProvider();
}
#endif

#if INTELLIVERSEX_HAS_VISIONOS
IVXVisionOSHelper.Instance.ConfigureSpatialUI(volumeCamera);
#endif

#if INTELLIVERSEX_HAS_ARFOUNDATION
IVXARHelper.Instance.StartSession(detectionMode: PlaneDetectionMode.Horizontal);
IVXARHelper.Instance.OnPlaneDetected += HandlePlaneDetected;
#endif

XR Input Abstraction¶

IVXXRInputAdapter provides a unified input layer across all XR platforms so your game code never references platform-specific APIs directly.

graph TD
    A[Your Game Code] --> B[IVXXRInputAdapter]
    B --> C{Active Platform}
    C -->|Meta Quest| D[IVXMetaXRInputProvider]
    C -->|OpenXR / SteamVR| E[IVXOpenXRInputProvider]
    C -->|Vision Pro| F[IVXVisionOSInputProvider]
    C -->|AR Foundation| G[IVXARInputProvider]
    C -->|Custom| H[Your IIVXXRInputProvider]

IIVXXRInputProvider Interface¶

namespace IntelliVerseX.Core
{
    /// <summary>
    /// Implement this interface to provide XR input from a custom platform.
    /// </summary>
    public interface IIVXXRInputProvider
    {
        /// <summary>The platform this provider supports.</summary>
        XRPlatform Platform { get; }

        /// <summary>Current head (HMD) pose in world space.</summary>
        Pose GetHeadPose();

        /// <summary>Pose of the specified hand/controller.</summary>
        Pose GetHandPose(XRHand hand);

        /// <summary>Gaze direction ray from the user's eyes.</summary>
        Ray GetGazeRay();

        /// <summary>Whether the primary action button is pressed.</summary>
        bool GetPrimaryButton(XRHand hand);

        /// <summary>Trigger axis value (0–1).</summary>
        float GetTriggerValue(XRHand hand);

        /// <summary>Grip axis value (0–1).</summary>
        float GetGripValue(XRHand hand);

        /// <summary>Thumbstick / touchpad 2D axis.</summary>
        Vector2 GetThumbstick(XRHand hand);

        /// <summary>Whether hand tracking is active (vs. controller).</summary>
        bool IsHandTrackingActive { get; }

        /// <summary>Whether eye tracking is available and active.</summary>
        bool IsEyeTrackingActive { get; }

        /// <summary>Trigger a haptic pulse on the specified hand.</summary>
        void SendHapticPulse(XRHand hand, float amplitude, float duration);
    }
}

Using the Adapter¶

var input = IVXXRInputAdapter.Instance;

Pose head = input.GetHeadPose();
Ray gaze = input.GetGazeRay();

if (input.GetPrimaryButton(XRHand.Right))
    FireProjectile(input.GetHandPose(XRHand.Right));

if (input.GetTriggerValue(XRHand.Left) > 0.8f)
    GrabObject();

Registering a Custom Provider¶

// At startup, before any XR input queries
IVXXRInputAdapter.Instance.RegisterProvider(new MyCustomInputProvider());

Recommended XR Settings¶

IVXXRPlatformHelper.GetRecommendedSettings() returns platform-tuned defaults:

var settings = IVXXRPlatformHelper.GetRecommendedSettings();
Application.targetFrameRate = settings.TargetFrameRate;
XRSettings.renderViewportScale = settings.RenderScale;

WebXR (Browser VR/AR)¶

For the JavaScript SDK, IntelliVerseX provides IVXWebXRHelper.ts to detect and manage browser-based XR sessions.

Session Detection¶

import { IVXWebXRHelper } from '@intelliversex/sdk';

const xr = new IVXWebXRHelper();

// Check device capabilities
const canVR = await xr.isSessionSupported('immersive-vr');   // Meta Quest Browser, desktop VR
const canAR = await xr.isSessionSupported('immersive-ar');   // Mobile Chrome AR

if (canVR) {
    enterVRButton.disabled = false;
    enterVRButton.onclick = () => xr.requestSession('immersive-vr', {
        requiredFeatures: ['local-floor'],
        optionalFeatures: ['hand-tracking', 'bounded-floor']
    });
}

WebXR + IntelliVerseX Backend¶

All IntelliVerseX backend modules (auth, leaderboards, Hiro RPCs, Satori events) work in WebXR because they use standard HTTP / WebSocket — no platform-specific APIs required.

// Inside a WebXR session, SDK calls work normally
await ivx.authenticateDevice();
await ivx.submitScore('vr_high_score', 42000);
ivx.satoriTrackEvent('xr_session_start', { mode: 'immersive-vr' });

Eye Tracking & Privacy¶

IntelliVerseX provides utility methods to handle this:

bool consented = await IVXXRPlatformHelper.RequestEyeTrackingConsentAsync();
if (consented)
{
    IVXXRInputAdapter.Instance.EnableEyeTracking();
}

The SDK never sends eye-tracking data to Nakama/Satori. If you need gaze analytics, aggregate locally (e.g., heatmap zones) and send only the aggregated result.

Best Practices¶

Architecture¶

• Always use compile defines — Keep the SDK zero-dependency on XR packages. A project without any XR SDK installed should compile cleanly.
• Test in XR Simulator — Use Meta XR Simulator or Unity's XR Device Simulator during development to iterate without a headset.
• World Space UI — For VR, set Canvas Render Mode to World Space and place panels at comfortable reading distance (1.5–2 m).
• Handle tracking loss — Subscribe to IVXXRPlatformHelper.OnTrackingLost and show a "return to play area" overlay.

Performance¶

• Frame rate is critical — Dropped frames cause nausea. Target 72–90 fps depending on platform (see table above).
• Avoid GC in render loop — All standard IntelliVerseX zero-GC rules apply doubly in XR.
• Use Single Pass Instanced rendering on all platforms that support it.
• GPU bound? — Lower render scale via XRSettings.renderViewportScale before reducing visual quality.

Comfort¶

• Never move the camera programmatically without a comfort vignette or snap-turn.
• Provide teleport + smooth locomotion options — let the user choose.
• Anchor UI to world, not head — Head-locked UI causes discomfort; use a follow-with-lag pattern if a HUD is needed.
• Respect the guardian/boundary — Use OVRBoundary or OpenXR bounds to warn users.

SDK Module Compatibility in XR¶

All IntelliVerseX modules that work on the base platform (Android, Windows, visionOS) continue to work in XR. There are no XR-specific module restrictions. The table below highlights XR-enhanced behaviors:

Folder Structure¶

Assets/_IntelliVerseXSDK/
└── Runtime/
    └── XR/
        ├── IVXXRPlatformHelper.cs       # Platform detection + recommended settings
        ├── IVXXRInputAdapter.cs          # Unified input singleton
        ├── IIVXXRInputProvider.cs        # Input provider interface
        ├── IVXMetaXRInputProvider.cs     # Meta Quest implementation
        ├── IVXOpenXRInputProvider.cs     # OpenXR / SteamVR implementation
        ├── IVXVisionOSHelper.cs          # Apple Vision Pro utilities
        ├── IVXARHelper.cs                # AR Foundation wrapper
        └── IVXWebXRHelper.ts             # JavaScript SDK WebXR helper (in SDKs/javascript/)

PSVR2 Integration¶

Setup¶

1. Obtain the PS VR2 Unity Plugin from Sony's PlayStation Partners portal.
2. Import into your Unity project targeting PS5.
3. The SDK detects XR loaders containing "PlayStation" or "PSVR" and sets XRPlatformType.PSVR2.

Capabilities¶

Recommended Settings¶

IVXXRPlatformHelper.GetRecommendedSettings() returns:

• Target frame rate: 90 fps
• Render scale: 1.0
• World-space UI: true
• Prefer hand tracking: false

Store Certification & Submission¶

Each VR platform has its own submission and certification requirements:

Meta Quest Store¶

SteamVR¶

Apple Vision Pro (App Store)¶

PSVR2 (PlayStation Store)¶

Troubleshooting¶