webxr_api/
session.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::thread;
6use std::time::Duration;
7
8use base::generic_channel::{self, GenericReceiver, GenericSender};
9use euclid::{Point2D, Rect, RigidTransform3D, Size2D};
10use ipc_channel::ipc::IpcSender;
11use log::warn;
12use malloc_size_of_derive::MallocSizeOf;
13use profile_traits::generic_callback::GenericCallback as ProfileGenericCallback;
14use serde::{Deserialize, Serialize};
15
16use crate::{
17    ContextId, DeviceAPI, Error, Event, Floor, Frame, FrameUpdateEvent, HitTestId, HitTestSource,
18    InputSource, LayerGrandManager, LayerId, LayerInit, Native, Viewport, Viewports,
19};
20
21// How long to wait for an rAF.
22static TIMEOUT: Duration = Duration::from_millis(5);
23
24/// <https://www.w3.org/TR/webxr/#xrsessionmode-enum>
25#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
26pub enum SessionMode {
27    Inline,
28    ImmersiveVR,
29    ImmersiveAR,
30}
31
32/// <https://immersive-web.github.io/webxr/#dictdef-xrsessioninit>
33#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
34pub struct SessionInit {
35    pub required_features: Vec<String>,
36    pub optional_features: Vec<String>,
37    /// Secondary views are enabled with the `secondary-view` feature
38    /// but for performance reasons we also ask users to enable this pref
39    /// for now.
40    pub first_person_observer_view: bool,
41}
42
43impl SessionInit {
44    /// Helper function for validating a list of requested features against
45    /// a list of supported features for a given mode
46    pub fn validate(&self, mode: SessionMode, supported: &[String]) -> Result<Vec<String>, Error> {
47        for f in &self.required_features {
48            // viewer and local in immersive are granted by default
49            // https://immersive-web.github.io/webxr/#default-features
50            if f == "viewer" || (f == "local" && mode != SessionMode::Inline) {
51                continue;
52            }
53
54            if !supported.contains(f) {
55                return Err(Error::UnsupportedFeature(f.into()));
56            }
57        }
58        let mut granted = self.required_features.clone();
59        for f in &self.optional_features {
60            if f == "viewer" ||
61                (f == "local" && mode != SessionMode::Inline) ||
62                supported.contains(f)
63            {
64                granted.push(f.clone());
65            }
66        }
67
68        Ok(granted)
69    }
70
71    pub fn feature_requested(&self, f: &str) -> bool {
72        self.required_features
73            .iter()
74            .chain(self.optional_features.iter())
75            .any(|x| *x == f)
76    }
77}
78
79/// <https://immersive-web.github.io/webxr-ar-module/#xrenvironmentblendmode-enum>
80#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize, MallocSizeOf)]
81pub enum EnvironmentBlendMode {
82    Opaque,
83    AlphaBlend,
84    Additive,
85}
86
87// The messages that are sent from the content thread to the session thread.
88#[derive(Debug, Serialize, Deserialize)]
89enum SessionMsg {
90    CreateLayer(ContextId, LayerInit, GenericSender<Result<LayerId, Error>>),
91    DestroyLayer(ContextId, LayerId),
92    SetLayers(Vec<(ContextId, LayerId)>),
93    SetEventDest(ProfileGenericCallback<Event>),
94    UpdateClipPlanes(/* near */ f32, /* far */ f32),
95    StartRenderLoop,
96    RenderAnimationFrame,
97    RequestHitTest(HitTestSource),
98    CancelHitTest(HitTestId),
99    UpdateFrameRate(f32, ProfileGenericCallback<f32>),
100    Quit,
101    GetBoundsGeometry(GenericSender<Option<Vec<Point2D<f32, Floor>>>>),
102}
103
104#[derive(Serialize, Deserialize, Clone)]
105pub struct Quitter {
106    sender: GenericSender<SessionMsg>,
107}
108
109impl Quitter {
110    pub fn quit(&self) {
111        let _ = self.sender.send(SessionMsg::Quit);
112    }
113}
114
115/// An object that represents an XR session.
116/// This is owned by the content thread.
117/// <https://www.w3.org/TR/webxr/#xrsession-interface>
118#[derive(Serialize, Deserialize, MallocSizeOf)]
119pub struct Session {
120    floor_transform: Option<RigidTransform3D<f32, Native, Floor>>,
121    viewports: Viewports,
122    sender: GenericSender<SessionMsg>,
123    environment_blend_mode: EnvironmentBlendMode,
124    initial_inputs: Vec<InputSource>,
125    granted_features: Vec<String>,
126    id: SessionId,
127    supported_frame_rates: Vec<f32>,
128}
129
130#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Deserialize, Serialize, MallocSizeOf)]
131pub struct SessionId(pub(crate) u32);
132
133impl Session {
134    pub fn id(&self) -> SessionId {
135        self.id
136    }
137
138    pub fn floor_transform(&self) -> Option<RigidTransform3D<f32, Native, Floor>> {
139        self.floor_transform
140    }
141
142    pub fn reference_space_bounds(&self) -> Option<Vec<Point2D<f32, Floor>>> {
143        let (sender, receiver) = generic_channel::channel()?;
144        let _ = self.sender.send(SessionMsg::GetBoundsGeometry(sender));
145        receiver.recv().ok()?
146    }
147
148    pub fn initial_inputs(&self) -> &[InputSource] {
149        &self.initial_inputs
150    }
151
152    pub fn environment_blend_mode(&self) -> EnvironmentBlendMode {
153        self.environment_blend_mode
154    }
155
156    pub fn viewports(&self) -> &[Rect<i32, Viewport>] {
157        &self.viewports.viewports
158    }
159
160    /// A resolution large enough to contain all the viewports.
161    /// <https://immersive-web.github.io/webxr/#recommended-webgl-framebuffer-resolution>
162    ///
163    /// Returns None if the session is inline
164    pub fn recommended_framebuffer_resolution(&self) -> Option<Size2D<i32, Viewport>> {
165        self.viewports()
166            .iter()
167            .fold(None::<Rect<_, _>>, |acc, vp| {
168                Some(acc.map(|a| a.union(vp)).unwrap_or(*vp))
169            })
170            .map(|rect| Size2D::new(rect.max_x(), rect.max_y()))
171    }
172
173    pub fn create_layer(&self, context_id: ContextId, init: LayerInit) -> Result<LayerId, Error> {
174        let Some((sender, receiver)) = generic_channel::channel() else {
175            return Err(Error::CommunicationError);
176        };
177        let _ = self
178            .sender
179            .send(SessionMsg::CreateLayer(context_id, init, sender));
180        receiver.recv().map_err(|_| Error::CommunicationError)?
181    }
182
183    /// Destroy a layer
184    pub fn destroy_layer(&self, context_id: ContextId, layer_id: LayerId) {
185        let _ = self
186            .sender
187            .send(SessionMsg::DestroyLayer(context_id, layer_id));
188    }
189
190    pub fn set_layers(&self, layers: Vec<(ContextId, LayerId)>) {
191        let _ = self.sender.send(SessionMsg::SetLayers(layers));
192    }
193
194    pub fn start_render_loop(&mut self) {
195        let _ = self.sender.send(SessionMsg::StartRenderLoop);
196    }
197
198    pub fn update_clip_planes(&mut self, near: f32, far: f32) {
199        let _ = self.sender.send(SessionMsg::UpdateClipPlanes(near, far));
200    }
201
202    pub fn set_event_dest(&mut self, dest: ProfileGenericCallback<Event>) {
203        let _ = self.sender.send(SessionMsg::SetEventDest(dest));
204    }
205
206    pub fn render_animation_frame(&mut self) {
207        let _ = self.sender.send(SessionMsg::RenderAnimationFrame);
208    }
209
210    pub fn end_session(&mut self) {
211        let _ = self.sender.send(SessionMsg::Quit);
212    }
213
214    pub fn apply_event(&mut self, event: FrameUpdateEvent) {
215        match event {
216            FrameUpdateEvent::UpdateFloorTransform(floor) => self.floor_transform = floor,
217            FrameUpdateEvent::UpdateViewports(vp) => self.viewports = vp,
218            FrameUpdateEvent::HitTestSourceAdded(_) => (),
219        }
220    }
221
222    pub fn granted_features(&self) -> &[String] {
223        &self.granted_features
224    }
225
226    pub fn request_hit_test(&self, source: HitTestSource) {
227        let _ = self.sender.send(SessionMsg::RequestHitTest(source));
228    }
229
230    pub fn cancel_hit_test(&self, id: HitTestId) {
231        let _ = self.sender.send(SessionMsg::CancelHitTest(id));
232    }
233
234    pub fn update_frame_rate(&mut self, rate: f32, sender: ProfileGenericCallback<f32>) {
235        let _ = self.sender.send(SessionMsg::UpdateFrameRate(rate, sender));
236    }
237
238    pub fn supported_frame_rates(&self) -> &[f32] {
239        &self.supported_frame_rates
240    }
241}
242
243#[derive(PartialEq)]
244enum RenderState {
245    NotInRenderLoop,
246    InRenderLoop,
247    PendingQuit,
248}
249
250/// For devices that want to do their own thread management, the `SessionThread` type is exposed.
251pub struct SessionThread<Device> {
252    receiver: GenericReceiver<SessionMsg>,
253    sender: GenericSender<SessionMsg>,
254    layers: Vec<(ContextId, LayerId)>,
255    pending_layers: Option<Vec<(ContextId, LayerId)>>,
256    frame_count: u64,
257    frame_sender: IpcSender<Frame>,
258    running: bool,
259    device: Device,
260    id: SessionId,
261    render_state: RenderState,
262}
263
264impl<Device> SessionThread<Device>
265where
266    Device: DeviceAPI,
267{
268    pub fn new(
269        mut device: Device,
270        frame_sender: IpcSender<Frame>,
271        id: SessionId,
272    ) -> Result<Self, Error> {
273        let Some((sender, receiver)) = generic_channel::channel() else {
274            return Err(Error::CommunicationError);
275        };
276        device.set_quitter(Quitter {
277            sender: sender.clone(),
278        });
279        let frame_count = 0;
280        let running = true;
281        let layers = Vec::new();
282        let pending_layers = None;
283        Ok(SessionThread {
284            sender,
285            receiver,
286            device,
287            layers,
288            pending_layers,
289            frame_count,
290            frame_sender,
291            running,
292            id,
293            render_state: RenderState::NotInRenderLoop,
294        })
295    }
296
297    pub fn new_session(&mut self) -> Session {
298        let floor_transform = self.device.floor_transform();
299        let viewports = self.device.viewports();
300        let sender = self.sender.clone();
301        let initial_inputs = self.device.initial_inputs();
302        let environment_blend_mode = self.device.environment_blend_mode();
303        let granted_features = self.device.granted_features().into();
304        let supported_frame_rates = self.device.supported_frame_rates();
305        Session {
306            floor_transform,
307            viewports,
308            sender,
309            initial_inputs,
310            environment_blend_mode,
311            granted_features,
312            id: self.id,
313            supported_frame_rates,
314        }
315    }
316
317    pub fn run(&mut self) {
318        while let Ok(msg) = self.receiver.recv() {
319            if !self.handle_msg(msg) {
320                self.running = false;
321                break;
322            }
323        }
324    }
325
326    fn handle_msg(&mut self, msg: SessionMsg) -> bool {
327        log::debug!("processing {:?}", msg);
328        match msg {
329            SessionMsg::SetEventDest(dest) => {
330                self.device.set_event_dest(dest);
331            },
332            SessionMsg::RequestHitTest(source) => {
333                self.device.request_hit_test(source);
334            },
335            SessionMsg::CancelHitTest(id) => {
336                self.device.cancel_hit_test(id);
337            },
338            SessionMsg::CreateLayer(context_id, layer_init, sender) => {
339                let result = self.device.create_layer(context_id, layer_init);
340                let _ = sender.send(result);
341            },
342            SessionMsg::DestroyLayer(context_id, layer_id) => {
343                self.layers.retain(|&(_, other_id)| layer_id != other_id);
344                self.device.destroy_layer(context_id, layer_id);
345            },
346            SessionMsg::SetLayers(layers) => {
347                self.pending_layers = Some(layers);
348            },
349            SessionMsg::StartRenderLoop => {
350                if let Some(layers) = self.pending_layers.take() {
351                    self.layers = layers;
352                }
353                let frame = match self.device.begin_animation_frame(&self.layers[..]) {
354                    Some(frame) => frame,
355                    None => {
356                        warn!("Device stopped providing frames, exiting");
357                        return false;
358                    },
359                };
360                self.render_state = RenderState::InRenderLoop;
361                let _ = self.frame_sender.send(frame);
362            },
363            SessionMsg::UpdateClipPlanes(near, far) => self.device.update_clip_planes(near, far),
364            SessionMsg::RenderAnimationFrame => {
365                self.frame_count += 1;
366
367                self.device.end_animation_frame(&self.layers[..]);
368
369                if self.render_state == RenderState::PendingQuit {
370                    self.quit();
371                    return false;
372                }
373
374                if let Some(layers) = self.pending_layers.take() {
375                    self.layers = layers;
376                }
377                #[expect(unused_mut)]
378                let mut frame = match self.device.begin_animation_frame(&self.layers[..]) {
379                    Some(frame) => frame,
380                    None => {
381                        warn!("Device stopped providing frames, exiting");
382                        return false;
383                    },
384                };
385
386                let _ = self.frame_sender.send(frame);
387            },
388            SessionMsg::UpdateFrameRate(rate, sender) => {
389                let new_framerate = self.device.update_frame_rate(rate);
390                let _ = sender.send(new_framerate);
391            },
392            SessionMsg::Quit => {
393                if self.render_state == RenderState::NotInRenderLoop {
394                    self.quit();
395                    return false;
396                } else {
397                    self.render_state = RenderState::PendingQuit;
398                }
399            },
400            SessionMsg::GetBoundsGeometry(sender) => {
401                let bounds = self.device.reference_space_bounds();
402                let _ = sender.send(bounds);
403            },
404        }
405        true
406    }
407
408    fn quit(&mut self) {
409        self.render_state = RenderState::NotInRenderLoop;
410        self.device.quit();
411    }
412}
413
414/// Devices that need to can run sessions on the main thread.
415pub trait MainThreadSession: 'static {
416    fn run_one_frame(&mut self);
417    fn running(&self) -> bool;
418}
419
420impl<Device> MainThreadSession for SessionThread<Device>
421where
422    Device: DeviceAPI,
423{
424    fn run_one_frame(&mut self) {
425        let frame_count = self.frame_count;
426        while frame_count == self.frame_count && self.running {
427            if let Ok(msg) = self.receiver.try_recv_timeout(TIMEOUT) {
428                self.running = self.handle_msg(msg);
429            } else {
430                break;
431            }
432        }
433    }
434
435    fn running(&self) -> bool {
436        self.running
437    }
438}
439
440/// A type for building XR sessions
441pub struct SessionBuilder<'a, GL> {
442    sessions: &'a mut Vec<Box<dyn MainThreadSession>>,
443    frame_sender: IpcSender<Frame>,
444    layer_grand_manager: LayerGrandManager<GL>,
445    id: SessionId,
446}
447
448impl<'a, GL: 'static> SessionBuilder<'a, GL> {
449    pub fn id(&self) -> SessionId {
450        self.id
451    }
452
453    pub(crate) fn new(
454        sessions: &'a mut Vec<Box<dyn MainThreadSession>>,
455        frame_sender: IpcSender<Frame>,
456        layer_grand_manager: LayerGrandManager<GL>,
457        id: SessionId,
458    ) -> Self {
459        SessionBuilder {
460            sessions,
461            frame_sender,
462            layer_grand_manager,
463            id,
464        }
465    }
466
467    /// For devices which are happy to hand over thread management to webxr.
468    pub fn spawn<Device, Factory>(self, factory: Factory) -> Result<Session, Error>
469    where
470        Factory: 'static + FnOnce(LayerGrandManager<GL>) -> Result<Device, Error> + Send,
471        Device: DeviceAPI,
472    {
473        let Some((acks, ackr)) = generic_channel::channel() else {
474            return Err(Error::CommunicationError);
475        };
476        let frame_sender = self.frame_sender;
477        let layer_grand_manager = self.layer_grand_manager;
478        let id = self.id;
479        thread::spawn(move || {
480            match factory(layer_grand_manager)
481                .and_then(|device| SessionThread::new(device, frame_sender, id))
482            {
483                Ok(mut thread) => {
484                    let session = thread.new_session();
485                    let _ = acks.send(Ok(session));
486                    thread.run();
487                },
488                Err(err) => {
489                    let _ = acks.send(Err(err));
490                },
491            }
492        });
493        ackr.recv().unwrap_or(Err(Error::CommunicationError))
494    }
495
496    /// For devices that need to run on the main thread.
497    pub fn run_on_main_thread<Device, Factory>(self, factory: Factory) -> Result<Session, Error>
498    where
499        Factory: 'static + FnOnce(LayerGrandManager<GL>) -> Result<Device, Error>,
500        Device: DeviceAPI,
501    {
502        let device = factory(self.layer_grand_manager)?;
503        let frame_sender = self.frame_sender;
504        let mut session_thread = SessionThread::new(device, frame_sender, self.id)?;
505        let session = session_thread.new_session();
506        self.sessions.push(Box::new(session_thread));
507        Ok(session)
508    }
509}
webxr_api/session.rs

webxr_api/
session.rs
