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

Einführung in Virtual Reality

Eine umfassende Einführung in die Virtual Reality, die die Grundlagen der Computergrafik, stereoskopisches Sehen, die Geschichte von VR, Gerätekategorien, Motion Tracking und das Reality-Virtuality-Kontinuum abdeckt.

XR-Performance: Optimierung der Echtzeit-Inferenz

Optimierung der KI-Inferenz für XR-Geräte — Modellquantisierung, NPU-Beschleunigung, hierarchisches Serving, Bandbreitenoptimierung für Echtzeit-Rendering mit 60 fps.

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.