Extended Reality: The Convergence of AR, VR, and MR 2026

class XRFundamentals:
    """
    Core XR concepts.
    """
    
    def six_degrees_of_freedom(self):
        """
        6DoF: How users move in XR.
        """
        return {
            '3DoF': 'Rotation only (pitch, yaw, roll)',
            '6DoF': 'Rotation + Position (x, y, z)',
            'room_scale': 'Full 6DoF in physical space',
            'stationary': '3DoF seated experience'
        }
    
    def presence(self):
        """
        The feeling of "being there."
        """
        return {
            'immersion': 'Technical depth of experience',
            'presence': 'Psychological sense of being there',
            'embodiment': 'Having a virtual body'
        }

class ARGlassesSpec:
    """
    AR glasses specifications.
    """
    
    def display_types(self):
        """
        AR display technologies.
        """
        return {
            'waveguide': {
                'description': 'Light guides through holographic optical elements',
                'providers': 'Microsoft HoloLens, Magic Leap',
                'pros': 'Compact, wearable',
                'cons': 'Limited FOV, brightness'
            },
            'birdbath': {
                'description': 'Reflected display above lens',
                'providers': 'Xreal, Rokid',
                'pros': 'Brighter, wider FOV',
                'cons': 'Bulkier'
            },
            'retinal_projection': {
                'description': 'Direct projection to retina',
                'providers': 'Experimental',
                'pros': 'True focus, compact',
                'cons': 'Not production-ready'
            }
        }
    
    def field_of_view(self):
        """
        Current FOV limitations.
        """
        return {
            'consumer_ar': '40-60 degrees horizontal',
            'enterprise_ar': '50-90 degrees horizontal',
            'target': '120+ degrees (human vision)',
            'challenge': 'Optical engineering, cost'
        }

class XRTracking:
    """
    XR tracking technologies.
    """
    
    def inside_out_tracking(self):
        """
        Cameras on headset track environment.
        """
        return {
            'method': 'Computer vision on headset cameras',
            'pros': 'No external sensors, portable',
            'cons': 'Limited range, occlusion issues',
            'devices': 'Quest 3, Apple Vision Pro'
        }
    
    def outside_in_tracking(self):
        """
        External sensors track headset.
        """
        return {
            'method': 'Base stations or cameras',
            'pros': 'Precise, large play area',
            'cons': 'Complex setup, less portable',
            'devices': 'HTC Vive, Varjo'
        }
    
    def eye_tracking(self):
        """
        Track user gaze.
        """
        return {
            'foveated_rendering': 'Render high-res where looking',
            'social_presence': 'Virtual eyes contact',
            'input': 'Eye-based interaction',
            'analytics': 'User attention tracking'
        }
    
    def hand_tracking(self):
        """
        Track hand movements.
        """
        return {
            'technology': 'Computer vision',
            'accuracy': 'Sub-millimeter in recent devices',
            'gestures': 'Natural hand interactions',
            'controllers': 'Still more precise for gaming'
        }

// WebXR: Browser-based VR/AR
async function initXR() {
    // Check for XR support
    if (navigator.xr) {
        const supported = await navigator.xr.isSessionSupported('immersive-vr');
        if (supported) {
            console.log('VR supported!');
        }
    }
}

class XRScene {
    constructor() {
        this.scene = new THREE.Scene();
        this.renderer = new THREE.WebGLRenderer({ xr: true });
    }
    
    async startSession() {
        // Request XR session
        this.session = await navigator.xr.requestSession('immersive-vr', {
            requiredFeatures: ['local-floor'],
            optionalFeatures: ['hand-tracking']
        });
        
        // Set up reference space
        this.refSpace = await this.session.requestReferenceSpace('local-floor');
        
        // Configure render loop
        this.renderer.xr.enabled = true;
        this.renderer.setAnimationLoop(this.render.bind(this));
    }
    
    render(timestamp, frame) {
        const session = this.renderer.xr.getSession();
        const pose = frame.getViewerPose(this.refSpace);
        
        if (pose) {
            // Render for each view (left/right eye)
            for (const view of pose.views) {
                const viewport = session.renderState.baseLayer.getViewport(view);
                this.renderer.setViewport(viewport.x, viewport.y, 
                                         viewport.width, viewport.height);
                
                // Render scene with view's projection matrix
                this.camera.projectionMatrix.fromArray(view.projectionMatrix);
                this.renderer.render(this.scene, this.camera);
            }
        }
    }
}

// Unity XR Interaction Toolkit
using UnityEngine;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit;

public class XRPlayerController : MonoBehaviour
{
    public XRController leftController;
    public XRController rightController;
    public XRRig rig;
    
    void Start()
    {
        // Initialize XR system
        XRGeneralSettings.Instance.Manager.InitializeLoader();
    }
    
    void Update()
    {
        // Get controller input
        InputDevice leftDevice = leftController.inputDevice;
        InputDevice rightDevice = rightController.inputDevice;
        
        // Read trigger value
        leftDevice.TryGetFeatureValue(CommonUsages.trigger, out float triggerValue);
        
        // Hand tracking
        if (leftDevice.TryGetHand(out Hand hand))
        {
            hand.TryGetFeatureValue(HandFinger.Index, out float curl);
        }
    }
}

// Grab and throw objects
public class GrabbableObject : MonoBehaviour
{
    public XRGrabInteractable interactable;
    
    void OnSelectEnter(XRBaseInteractor interactor)
    {
        // Object picked up
        GetComponent<Rigidbody>().isKinematic = true;
    }
    
    void OnSelectExit(XRBaseInteractor interactor)
    {
        // Calculate throw velocity from controller
        GetComponent<Rigidbody>().isKinematic = false;
        GetComponent<Rigidbody>().velocity = CalculateThrowVelocity();
    }
}

class EnterpriseXR:
    """
    XR for business.
    """
    
    def training(self):
        """
        Immersive training applications.
        """
        return {
            'safety_training': 'Hazardous environments without risk',
            'medical_training': 'Surgery simulation',
            'manufacturing': 'Equipment operation',
            'customer_service': 'Role-play scenarios',
            'benefits': {
                'retention': '75% vs 10% for lectures',
                'practice': 'Unlimited repetitions',
                'feedback': 'Real-time performance tracking'
            }
        }
    
    def design_collaboration(self):
        """
        3D design review.
        """
        return {
            'architecture': 'Walk through buildings pre-construction',
            'product_design': 'Review prototypes virtually',
            'automotive': 'Design reviews in virtual space',
            'collaboration': 'Distributed teams in same virtual room'
        }
    
    def remote_assistance(self):
        """
        AR-guided maintenance.
        """
        return {
            'use_case': 'Technician with AR glasses gets remote guidance',
            'overlay': 'Step-by-step instructions appear in view',
            'annotation': 'Expert draws on technician\'s view',
            'devices': 'RealWear, Vuzix, Microsoft HoloLens'
        }

class HealthcareXR:
    """
    XR in medicine.
    """
    
    def surgical_planning(self):
        """
        Pre-operative visualization.
        """
        return {
            'ct_scan_import': 'Convert scans to 3D models',
            'patient_specific': 'See exact anatomy',
            'surgical_approach': 'Plan incisions before entering OR',
            'training': 'Practice on virtual patient'
        }
    
    def therapy(self):
        """
        XR for treatment.
        """
        return {
            'pt_rehab': 'Gamified physical therapy',
            'exposure_therapy': 'Treat phobias, PTSD',
            'pain_management': 'Distraction during procedures',
            'cognitive': 'Memory games for elderly'
        }

class EducationXR:
    """
    Immersive learning.
    """
    
    def virtual_field_trips(self):
        """
        Visit places impossible in real life.
        """
        return {
            'ancient_rome': 'Walk through historical sites',
            'inside_atom': 'Explore subatomic particles',
            'space': 'Tour solar system',
            'inside_body': 'Travel through circulatory system'
        }
    
    def stem_education(self):
        """
        Interactive science and math.
        """
        return {
            'chemistry': 'Mix virtual chemicals safely',
            'physics': 'Experiment with gravity, forces',
            'math': 'Visualize 3D geometry',
            'biology': 'Dissect virtual frogs'
        }

class MetaverseTech:
    """
    Building blocks of the metaverse.
    """
    
    def digital_twins(self):
        """
        Real-world replication.
        """
        return {
            'cities': 'Urban planning, traffic simulation',
            'factories': 'Process optimization',
            'stores': 'Retail visualization',
            'buildings': 'Architectural visualization'
        }
    
    def avatars(self):
        """
        Digital representations.
        """
        return {
            'photorealistic': 'MetaHumans, Ready Player Me',
            'expressive': 'Full body tracking',
            'interoperable': 'Cross-platform avatars',
            'identity': 'Persistent digital identity'
        }
    
    def virtual_worlds(self):
        """
        Persistent shared spaces.
        """
        return {
            'decentraland': 'Blockchain-based virtual world',
            'horizon_worlds': 'Meta social platform',
            'vrchat': 'Social VR community',
            'spatial': 'Enterprise collaboration'
        }

class XROptimization:
    """
    Optimize XR experiences.
    """
    
    def frame_rate_requirements(self):
        """
        Maintain high framerate.
        """
        return {
            'target': '72-120 fps minimum',
            'below_threshold': 'Causes nausea',
            'pro_tip': 'Dynamic resolution scaling',
            'testing': 'Test on lowest-end device'
        }
    
    def foveated_rendering(self):
        """
        Render high-res only where looking.
        """
        return {
            'technique': 'Eye tracking determines gaze point',
            'savings': 'Up to 70% GPU savings',
            'implementation': 'Eye tracking required',
            'result': 'Higher perceived resolution'
        }
    
    def latency_budget(self):
        """
        Motion-to-photon latency.
        """
        return {
            'target': 'Under 20ms',
            'components': [
                'Input processing',
                'App update', 
                'GPU render',
                'Display scan-out'
            ],
            'fix': 'Asynchronous reprojection'
        }

class XRDesignGuidelines:
    """
    Best practices for XR.
    """
    
    def comfort(self):
        """
        User comfort guidelines.
        """
        return {
            'stable_horizon': 'Never unexpectedly rotate view',
            'user_control': 'Let users control their experience',
            'comfortable_interactions': 'Stay in natural arm range',
            'movement': 'Use teleportation, avoid continuous motion'
        }
    
    def accessibility(self):
        """
        Inclusive design.
        """
        return {
            'one_handed': 'Support single-hand use',
            'seated_standing': 'Design for both',
            'hearing_impairments': 'Visual alternatives to audio',
            'motion_sickness': 'Provide seated option'
        }