wip

Cargo.toml

@@ -13,3 +13,11 @@ opt-level = 3
 # Uncomment to profile on Linux:
 # debug = true
 # lto = false
+
+[replace]
+"rust-webvr:0.3.1" = { path = "/home/mortimer/Projects/rust-webvr" }
+"servo-glutin:0.10.1" = { path = "/home/mortimer/Projects/glutin" }
+"https://github.com/servo/webrender#0.31.0" = { path = "/home/mortimer/Projects/webrender/webrender" }
+"https://github.com/servo/webrender#webrender_traits:0.32.0" = { path = "/home/mortimer/Projects/webrender/webrender_traits" }
+"offscreen_gl_context:0.8.6" = { path = "/home/mortimer/Projects/rust-offscreen-rendering-context" }
+"gleam:0.4.2" = { path = "/home/mortimer/Projects/gleam" }

components/script/dom/gamepad.rs

@@ -47,7 +47,6 @@ impl Gamepad {
                      connected: bool,
                      timestamp: f64,
                      mapping_type: String,
-                     axes: *mut JSObject,
                      buttons: &GamepadButtonList,
                      pose: Option<&VRPose>,
                      hand: WebVRGamepadHand,
@@ -60,7 +59,7 @@ impl Gamepad {
             connected: Cell::new(connected),
             timestamp: Cell::new(timestamp),
             mapping_type: mapping_type,
-            axes: Heap::new(axes),
+            axes: Heap::default(),
             buttons: JS::from_ref(buttons),
             pose: pose.map(JS::from_ref),
             hand: hand,
@@ -75,27 +74,27 @@ impl Gamepad {
                        state: &WebVRGamepadState) -> Root<Gamepad> {
         let buttons = GamepadButtonList::new_from_vr(&global, &state.buttons);
         let pose = VRPose::new(&global, &state.pose);
+
+        let root = reflect_dom_object(box Gamepad::new_inherited(state.gamepad_id,
+                                                                 data.name.clone(),
+                                                                 index,
+                                                                 state.connected,
+                                                                 state.timestamp,
+                                                                 "".into(),
+                                                                 &buttons,
+                                                                 Some(&pose),
+                                                                 data.hand.clone(),
+                                                                 data.display_id),
+                                          global,
+                                          GamepadBinding::Wrap);
         let cx = global.get_cx();
-        rooted!(in (cx) let mut axes = ptr::null_mut());
+        rooted!(in (cx) let mut array = ptr::null_mut());
         unsafe {
-            let _ = Float64Array::create(cx,
-                                         CreateWith::Slice(&state.axes),
-                                         axes.handle_mut());
+           let _ = Float64Array::create(cx, CreateWith::Slice(&state.axes), array.handle_mut());
         }
+        root.axes.set(array.get());
 
-        reflect_dom_object(box Gamepad::new_inherited(state.gamepad_id,
-                                                      data.name.clone(),
-                                                      index,
-                                                      state.connected,
-                                                      state.timestamp,
-                                                      "".into(),
-                                                      axes.get(),
-                                                      &buttons,
-                                                      Some(&pose),
-                                                      data.hand.clone(),
-                                                      data.display_id),
-                           global,
-                           GamepadBinding::Wrap)
+        root
 
     }
 }
@@ -200,7 +199,8 @@ impl Gamepad {
     }
 
     pub fn notify_event(&self, event_type: GamepadEventType) {
-        let event = GamepadEvent::new_with_type(&self.global(), event_type, &self);
+        let root = Root::from_ref(&*self);
+        let event = GamepadEvent::new_with_type(&self.global(), event_type, &root);
         event.upcast::<Event>().fire(self.global().as_window().upcast::<EventTarget>());
     }
 }

components/script/dom/vr.rs

@@ -152,6 +152,13 @@ impl VR {
             WebVRDisplayEvent::Change(ref display) => {
                 let display = self.sync_display(&display);
                 display.handle_webvr_event(&event);
+            },
+            WebVRDisplayEvent::Pause(id) |
+            WebVRDisplayEvent::Resume(id) |
+            WebVRDisplayEvent::Exit(id) => {
+                if let Some(display) = self.find_display(id) {
+                    display.handle_webvr_event(&event);
+                }
             }
         };
     }

components/script/dom/vrdisplay.rs

@@ -71,7 +71,9 @@ pub struct VRDisplay {
     frame_data_status: Cell<VRFrameDataStatus>,
     #[ignore_heap_size_of = "channels are hard"]
     frame_data_receiver: DOMRefCell<Option<IpcReceiver<Result<Vec<u8>, ()>>>>,
-    running_display_raf: Cell<bool>
+    running_display_raf: Cell<bool>,
+    paused: Cell<bool>,
+    stopped_on_pause: Cell<bool>,
 }
 
 unsafe_no_jsmanaged_fields!(WebVRDisplayData);
@@ -112,6 +114,8 @@ impl VRDisplay {
             frame_data_status: Cell::new(VRFrameDataStatus::Waiting),
             frame_data_receiver: DOMRefCell::new(None),
             running_display_raf: Cell::new(false),
+            paused: Cell::new(false),
+            stopped_on_pause: Cell::new(false)
         }
     }
 
@@ -428,6 +432,27 @@ impl VRDisplay {
                 // Change event doesn't exist in WebVR spec.
                 // So we update display data but don't notify JS.
                 self.update_display(&display);
+            },
+            WebVRDisplayEvent::Pause(_) => {
+                if self.paused.get() {
+                    return;
+                }
+                self.paused.set(true);
+                if self.presenting.get() {
+                    self.stop_present();
+                    self.stopped_on_pause.set(true);
+                }
+
+            },
+            WebVRDisplayEvent::Resume(_) => {
+                self.paused.set(false);
+                if self.stopped_on_pause.get() {
+                    self.stopped_on_pause.set(false);
+                    self.init_present();
+                }
+            },
+            WebVRDisplayEvent::Exit(ref display) => {
+                self.stopped_on_pause.set(false);
             }
         };
     }

components/script/dom/vrdisplayevent.rs

@@ -66,7 +66,12 @@ impl VRDisplayEvent {
             WebVRDisplayEvent::Blur(_) => ("blur", None),
             WebVRDisplayEvent::Focus(_) => ("focus", None),
             WebVRDisplayEvent::PresentChange(_, _) => ("presentchange", None),
-            WebVRDisplayEvent::Change(_) => panic!("VRDisplayEvent:Change event not available in WebVR")
+            WebVRDisplayEvent::Change(_) |
+            WebVRDisplayEvent::Pause(_) |
+            WebVRDisplayEvent::Resume(_) |
+            WebVRDisplayEvent::Exit(_) => {
+                panic!("{:?} event not available in WebVR", event)
+            }
         };
 
         // map to JS enum values

components/script/dom/vreyeparameters.rs

@@ -14,6 +14,7 @@ use dom_struct::dom_struct;
 use js::jsapi::{Heap, JSContext, JSObject};
 use js::typedarray::{Float32Array, CreateWith};
 use std::default::Default;
+use std::ptr;
 use webvr_traits::WebVREyeParameters;
 
 #[dom_struct]
@@ -28,29 +29,31 @@ pub struct VREyeParameters {
 unsafe_no_jsmanaged_fields!(WebVREyeParameters);
 
 impl VREyeParameters {
-    #[allow(unsafe_code)]
-    #[allow(unrooted_must_root)]
-    fn new_inherited(parameters: WebVREyeParameters, global: &GlobalScope) -> VREyeParameters {
-        let fov = VRFieldOfView::new(&global, parameters.field_of_view.clone());
-        let result = VREyeParameters {
+    fn new_inherited(parameters: WebVREyeParameters, fov: &VRFieldOfView) -> VREyeParameters {
+        VREyeParameters {
             reflector_: Reflector::new(),
             parameters: DOMRefCell::new(parameters),
             offset: Heap::default(),
             fov: JS::from_ref(&*fov)
-        };
-
-        unsafe {
-            let _ = Float32Array::create(global.get_cx(),
-                                         CreateWith::Slice(&result.parameters.borrow().offset),
-                                         result.offset.handle_mut());
         }
-        result
     }
 
+    #[allow(unsafe_code)]
     pub fn new(parameters: WebVREyeParameters, global: &GlobalScope) -> Root<VREyeParameters> {
-        reflect_dom_object(box VREyeParameters::new_inherited(parameters, global),
-                           global,
-                           VREyeParametersBinding::Wrap)
+        let fov = VRFieldOfView::new(&global, parameters.field_of_view.clone());
+
+        let cx = global.get_cx();
+        rooted!(in (cx) let mut array = ptr::null_mut());
+        unsafe {
+            let _ = Float32Array::create(cx, CreateWith::Slice(&parameters.offset), array.handle_mut());
+        }
+
+        let root = reflect_dom_object(box VREyeParameters::new_inherited(parameters, &fov),
+                                      global,
+                                      VREyeParametersBinding::Wrap);
+        root.offset.set(array.get());
+
+        root
     }
 }