Unity XR-Entwicklung: Einrichtung für Meta Quest und Vision Pro

XR Performance: Real-Time Inference Optimization

Optimizing AI inference for XR devices — model quantization, NPU acceleration, hierarchical serving, bandwidth optimization for real-time 60fps rendering.

WebXR + AI in 2026: Where the Platform Actually Is Today

WebGPU hit Baseline, Safari finally shipped WebXR, AI-assisted XR development landed from Meta and Google, and adoption surged 40%. A no-hype look at the immersive web ecosystem in mid-2026.

Unity ist die beliebteste Engine für die XR-Entwicklung. Dieser Leitfaden beschreibt die Einrichtung von Projekten sowohl für Meta Quest als auch für Apple Vision Pro.

Projekt-Setup

Anforderungen

• Unity 2022.3 LTS oder 2023.2+
• XR Plugin Management Package
• XR Interaction Toolkit
• Plattformspezifische SDKs

XR-Projekt erstellen

1. Unity Hub öffnen → New Project
2. Template "3D (URP)" auswählen
3. Projekt benennen

XR-Packages installieren

Window → Package Manager → Unity Registry

Install:
- XR Plugin Management
- XR Interaction Toolkit
- OpenXR Plugin
- XR Hands
```text

## Meta Quest Setup

### XR Plugin Konfiguration

```text
Edit → Project Settings → XR Plug-in Management

✓ Oculus
✓ OpenXR (optional, for cross-platform)
```text

### Quest-Features

```text
Edit → Project Settings → XR Plug-in Management → Oculus

✓ Shared Depth Buffer
✓ Low Overhead Mode (optional)
✓ Hand Tracking Support
✓ Passthrough Support
```text

### Build-Einstellungen

```text
File → Build Settings

Platform: Android
Texture Compression: ASTC
Graphics APIs: OpenGLES3 + Vulkan
```text

### Android Manifest

Hinzufügen zu `Assets/Plugins/Android/AndroidManifest.xml`:

```xml
<uses-feature android:name="android.hardware.vr.headtracking" />
<uses-permission android:name="com.oculus.permission.HAND_TRACKING" />
```text

## Apple Vision Pro Setup

### Anforderungen

- Unity 2023.2.4f1+
- Xcode 15.2+
- visionOS SDK

### XR Plugin Konfiguration

```text
Edit → Project Settings → XR Plug-in Management

✓ Apple visionOS
```text

### Build-Einstellungen

```text
File → Build Settings

Platform: iOS (visionOS)
Architecture: ARM64
```text

### Erforderliche Capabilities

In den Xcode-Projekteinstellungen:

- ARKit capability
- Hand Tracking capability

## XR Interaction Toolkit

### Basis-Setup

```csharp
using UnityEngine;
using UnityEngine.XR.Interaction.Toolkit;

public class XRSetup : MonoBehaviour
{
    void Start()
    {
        var xrOrigin = FindObjectOfType<XROrigin>();
        var locomotion = xrOrigin.GetComponent<ActionBasedContinuousMoveProvider>();
    }
}
```text
### Grab Interactable

```csharp
using UnityEngine.XR.Interaction.Toolkit;

public class GrabbableItem : XRGrabInteractable
{
    protected override void OnSelectEntered(SelectEnterEventArgs args)
    {
        base.OnSelectEntered(args);
        // Object grabbed
    }

    protected override void OnSelectExited(SelectExitEventArgs args)
    {
        base.OnSelectExited(args);
        // Object released
    }
}
```text

## Hand-Tracking

### Hand-Tracking aktivieren

```csharp
using UnityEngine.XR.Hands;

public class HandTrackingExample : MonoBehaviour
{
    XRHandSubsystem handSubsystem;

    void Start()
    {
        var manager = XRGeneralSettings.Instance?.Manager?.activeLoader?.GetLoadedSubsystem<XRHandSubsystem>();
        handSubsystem = manager;
    }

    void Update()
    {
        if (handSubsystem != null)
        {
            handSubsystem.TryUpdateHands(XRHandSubsystem.UpdateType.Dynamic);

            var leftHand = handSubsystem.leftHand;
            var thumbTip = leftHand.GetJoint(XRHandJointID.ThumbTip);

            if (thumbTip.TryGetPose(out var pose))
            {
                transform.position = pose.position;
            }
        }
    }
}
```text

### Gestenerkennung

```csharp
public class PinchDetector : MonoBehaviour
{
    public float pinchThreshold = 0.02f;

    public bool IsPinching(XRHand hand)
    {
        var thumbTip = hand.GetJoint(XRHandJointID.ThumbTip);
        var indexTip = hand.GetJoint(XRHandJointID.IndexTip);

        if (thumbTip.TryGetPose(out var thumbPose) &&
            indexTip.TryGetPose(out var indexPose))
        {
            float distance = Vector3.Distance(thumbPose.position, indexPose.position);
            return distance < pinchThreshold;
        }
        return false;
    }
}
```text

## Passthrough (Meta Quest)

### Passthrough aktivieren

```csharp
using UnityEngine.XR.Management;
using UnityEngine.XR;

public class PassthroughController : MonoBehaviour
{
    OVRPassthrough passthrough;
    OVRManager ovrManager;

    void Start()
    {
        ovrManager = FindObjectOfType<OVRManager>();
        passthrough = gameObject.AddComponent<OVRPassthrough>();
        passthrough.Enable();
    }

    public void SetPassthroughEnabled(bool enabled)
    {
        if (enabled)
            passthrough.Enable();
        else
            passthrough.Disable();
    }
}
```text

## Room Setup (Vision Pro)

```csharp
using UnityEngine.XR.ARKit;

public class RoomSetupController : MonoBehaviour
{
    ARKitSessionSubsystem arKitSession;

    void Start()
{
        arKitSession = XRGeneralSettings.Instance?.Manager?.activeLoader?.GetLoadedSubsystem<ARKitSessionSubsystem>();
    }

    void RequestRoomMapping()
    {
        if (arKitSession != null)
        {
            arKitSession.RequestRoomMapping();
        }
    }
}
```text

## Build and Deploy

### Meta Quest

```bash
# APK erstellen
File → Build Settings → Build

# Via ADB bereitstellen
adb install -r build.apk

# Oder Oculus Developer Hub verwenden
```text

### Apple Vision Pro

```bash
# Für Gerät erstellen
File → Build Settings → Build And Run

# Oder Xcode-Projekt erstellen
File → Build Settings → Build (erstellt .xcodeproj)
# In Xcode öffnen → visionOS-Target auswählen → Deploy
```text

## Conclusion

Unity XR development requires platform-specific setup but shares common interaction patterns. Start with XR Interaction Toolkit, add platform-specific features as needed.