summaryrefslogtreecommitdiffstats
path: root/dom/vr/VRDisplay.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/vr/VRDisplay.cpp')
-rw-r--r--dom/vr/VRDisplay.cpp802
1 files changed, 802 insertions, 0 deletions
diff --git a/dom/vr/VRDisplay.cpp b/dom/vr/VRDisplay.cpp
new file mode 100644
index 000000000..80922422f
--- /dev/null
+++ b/dom/vr/VRDisplay.cpp
@@ -0,0 +1,802 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsWrapperCache.h"
+
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ElementBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/VRDisplay.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "mozilla/dom/VRDisplayBinding.h"
+#include "Navigator.h"
+#include "gfxVR.h"
+#include "VRDisplayClient.h"
+#include "VRManagerChild.h"
+#include "VRDisplayPresentation.h"
+#include "nsIObserverService.h"
+#include "nsIFrame.h"
+#include "nsISupportsPrimitives.h"
+
+using namespace mozilla::gfx;
+
+namespace mozilla {
+namespace dom {
+
+VRFieldOfView::VRFieldOfView(nsISupports* aParent,
+ double aUpDegrees, double aRightDegrees,
+ double aDownDegrees, double aLeftDegrees)
+ : mParent(aParent)
+ , mUpDegrees(aUpDegrees)
+ , mRightDegrees(aRightDegrees)
+ , mDownDegrees(aDownDegrees)
+ , mLeftDegrees(aLeftDegrees)
+{
+}
+
+VRFieldOfView::VRFieldOfView(nsISupports* aParent, const gfx::VRFieldOfView& aSrc)
+ : mParent(aParent)
+ , mUpDegrees(aSrc.upDegrees)
+ , mRightDegrees(aSrc.rightDegrees)
+ , mDownDegrees(aSrc.downDegrees)
+ , mLeftDegrees(aSrc.leftDegrees)
+{
+}
+
+bool
+VRDisplayCapabilities::HasPosition() const
+{
+ return bool(mFlags & gfx::VRDisplayCapabilityFlags::Cap_Position);
+}
+
+bool
+VRDisplayCapabilities::HasOrientation() const
+{
+ return bool(mFlags & gfx::VRDisplayCapabilityFlags::Cap_Orientation);
+}
+
+bool
+VRDisplayCapabilities::HasExternalDisplay() const
+{
+ return bool(mFlags & gfx::VRDisplayCapabilityFlags::Cap_External);
+}
+
+bool
+VRDisplayCapabilities::CanPresent() const
+{
+ return bool(mFlags & gfx::VRDisplayCapabilityFlags::Cap_Present);
+}
+
+uint32_t
+VRDisplayCapabilities::MaxLayers() const
+{
+ return CanPresent() ? 1 : 0;
+}
+
+/*static*/ bool
+VRDisplay::RefreshVRDisplays(uint64_t aWindowId)
+{
+ gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
+ return vm && vm->RefreshVRDisplaysWithCallback(aWindowId);
+}
+
+/*static*/ void
+VRDisplay::UpdateVRDisplays(nsTArray<RefPtr<VRDisplay>>& aDisplays, nsPIDOMWindowInner* aWindow)
+{
+ nsTArray<RefPtr<VRDisplay>> displays;
+
+ gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
+ nsTArray<RefPtr<gfx::VRDisplayClient>> updatedDisplays;
+ if (vm && vm->GetVRDisplays(updatedDisplays)) {
+ for (size_t i = 0; i < updatedDisplays.Length(); i++) {
+ RefPtr<gfx::VRDisplayClient> display = updatedDisplays[i];
+ bool isNewDisplay = true;
+ for (size_t j = 0; j < aDisplays.Length(); j++) {
+ if (aDisplays[j]->GetClient()->GetDisplayInfo() == display->GetDisplayInfo()) {
+ displays.AppendElement(aDisplays[j]);
+ isNewDisplay = false;
+ }
+ }
+
+ if (isNewDisplay) {
+ displays.AppendElement(new VRDisplay(aWindow, display));
+ }
+ }
+ }
+
+ aDisplays = displays;
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(VRFieldOfView, mParent)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(VRFieldOfView, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(VRFieldOfView, Release)
+
+
+JSObject*
+VRFieldOfView::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto)
+{
+ return VRFieldOfViewBinding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(VREyeParameters)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(VREyeParameters)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent, mFOV)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->mOffset = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(VREyeParameters)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent, mFOV)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(VREyeParameters)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mOffset)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(VREyeParameters, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(VREyeParameters, Release)
+
+VREyeParameters::VREyeParameters(nsISupports* aParent,
+ const gfx::Point3D& aEyeTranslation,
+ const gfx::VRFieldOfView& aFOV,
+ const gfx::IntSize& aRenderSize)
+ : mParent(aParent)
+ , mEyeTranslation(aEyeTranslation)
+ , mRenderSize(aRenderSize)
+{
+ mFOV = new VRFieldOfView(aParent, aFOV);
+ mozilla::HoldJSObjects(this);
+}
+
+VREyeParameters::~VREyeParameters()
+{
+ mozilla::DropJSObjects(this);
+}
+
+VRFieldOfView*
+VREyeParameters::FieldOfView()
+{
+ return mFOV;
+}
+
+void
+VREyeParameters::GetOffset(JSContext* aCx, JS::MutableHandle<JSObject*> aRetval, ErrorResult& aRv)
+{
+ if (!mOffset) {
+ // Lazily create the Float32Array
+ mOffset = dom::Float32Array::Create(aCx, this, 3, mEyeTranslation.components);
+ if (!mOffset) {
+ aRv.NoteJSContextException(aCx);
+ return;
+ }
+ }
+ aRetval.set(mOffset);
+}
+
+JSObject*
+VREyeParameters::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return VREyeParametersBinding::Wrap(aCx, this, aGivenProto);
+}
+
+VRStageParameters::VRStageParameters(nsISupports* aParent,
+ const gfx::Matrix4x4& aSittingToStandingTransform,
+ const gfx::Size& aSize)
+ : mParent(aParent)
+ , mSittingToStandingTransform(aSittingToStandingTransform)
+ , mSittingToStandingTransformArray(nullptr)
+ , mSize(aSize)
+{
+ mozilla::HoldJSObjects(this);
+}
+
+VRStageParameters::~VRStageParameters()
+{
+ mozilla::DropJSObjects(this);
+}
+
+JSObject*
+VRStageParameters::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return VRStageParametersBinding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(VRStageParameters)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(VRStageParameters)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->mSittingToStandingTransformArray = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(VRStageParameters)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(VRStageParameters)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mSittingToStandingTransformArray)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(VRStageParameters, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(VRStageParameters, Release)
+
+void
+VRStageParameters::GetSittingToStandingTransform(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ if (!mSittingToStandingTransformArray) {
+ // Lazily create the Float32Array
+ mSittingToStandingTransformArray = dom::Float32Array::Create(aCx, this, 16,
+ mSittingToStandingTransform.components);
+ if (!mSittingToStandingTransformArray) {
+ aRv.NoteJSContextException(aCx);
+ return;
+ }
+ }
+ aRetval.set(mSittingToStandingTransformArray);
+}
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(VRDisplayCapabilities, mParent)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(VRDisplayCapabilities, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(VRDisplayCapabilities, Release)
+
+JSObject*
+VRDisplayCapabilities::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return VRDisplayCapabilitiesBinding::Wrap(aCx, this, aGivenProto);
+}
+
+VRPose::VRPose(nsISupports* aParent, const gfx::VRHMDSensorState& aState)
+ : Pose(aParent)
+ , mVRState(aState)
+{
+ mFrameId = aState.inputFrameID;
+ mozilla::HoldJSObjects(this);
+}
+
+VRPose::VRPose(nsISupports* aParent)
+ : Pose(aParent)
+{
+ mFrameId = 0;
+ mVRState.Clear();
+ mozilla::HoldJSObjects(this);
+}
+
+VRPose::~VRPose()
+{
+ mozilla::DropJSObjects(this);
+}
+
+void
+VRPose::GetPosition(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mPosition, mVRState.position, 3,
+ !mPosition && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Position),
+ aRv);
+}
+
+void
+VRPose::GetLinearVelocity(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mLinearVelocity, mVRState.linearVelocity, 3,
+ !mLinearVelocity && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Position),
+ aRv);
+}
+
+void
+VRPose::GetLinearAcceleration(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mLinearAcceleration, mVRState.linearAcceleration, 3,
+ !mLinearAcceleration && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_LinearAcceleration),
+ aRv);
+
+}
+
+void
+VRPose::GetOrientation(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mOrientation, mVRState.orientation, 4,
+ !mOrientation && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Orientation),
+ aRv);
+}
+
+void
+VRPose::GetAngularVelocity(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mAngularVelocity, mVRState.angularVelocity, 3,
+ !mAngularVelocity && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Orientation),
+ aRv);
+}
+
+void
+VRPose::GetAngularAcceleration(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ SetFloat32Array(aCx, aRetval, mAngularAcceleration, mVRState.angularAcceleration, 3,
+ !mAngularAcceleration && bool(mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_AngularAcceleration),
+ aRv);
+}
+
+JSObject*
+VRPose::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return VRPoseBinding::Wrap(aCx, this, aGivenProto);
+}
+
+/* virtual */ JSObject*
+VRDisplay::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return VRDisplayBinding::Wrap(aCx, this, aGivenProto);
+}
+
+VRDisplay::VRDisplay(nsPIDOMWindowInner* aWindow, gfx::VRDisplayClient* aClient)
+ : DOMEventTargetHelper(aWindow)
+ , mClient(aClient)
+ , mDepthNear(0.01f) // Default value from WebVR Spec
+ , mDepthFar(10000.0f) // Default value from WebVR Spec
+{
+ const gfx::VRDisplayInfo& info = aClient->GetDisplayInfo();
+ mDisplayId = info.GetDisplayID();
+ mDisplayName = NS_ConvertASCIItoUTF16(info.GetDisplayName());
+ mCapabilities = new VRDisplayCapabilities(aWindow, info.GetCapabilities());
+ if (info.GetCapabilities() & gfx::VRDisplayCapabilityFlags::Cap_StageParameters) {
+ mStageParameters = new VRStageParameters(aWindow,
+ info.GetSittingToStandingTransform(),
+ info.GetStageSize());
+ }
+ mozilla::HoldJSObjects(this);
+}
+
+VRDisplay::~VRDisplay()
+{
+ ExitPresentInternal();
+ mozilla::DropJSObjects(this);
+}
+
+void
+VRDisplay::LastRelease()
+{
+ // We don't want to wait for the CC to free up the presentation
+ // for use in other documents, so we do this in LastRelease().
+ ExitPresentInternal();
+}
+
+already_AddRefed<VREyeParameters>
+VRDisplay::GetEyeParameters(VREye aEye)
+{
+ gfx::VRDisplayInfo::Eye eye = aEye == VREye::Left ? gfx::VRDisplayInfo::Eye_Left : gfx::VRDisplayInfo::Eye_Right;
+ RefPtr<VREyeParameters> params =
+ new VREyeParameters(GetParentObject(),
+ mClient->GetDisplayInfo().GetEyeTranslation(eye),
+ mClient->GetDisplayInfo().GetEyeFOV(eye),
+ mClient->GetDisplayInfo().SuggestedEyeResolution());
+ return params.forget();
+}
+
+VRDisplayCapabilities*
+VRDisplay::Capabilities()
+{
+ return mCapabilities;
+}
+
+VRStageParameters*
+VRDisplay::GetStageParameters()
+{
+ return mStageParameters;
+}
+
+void
+VRDisplay::UpdateFrameInfo()
+{
+ /**
+ * The WebVR 1.1 spec Requires that VRDisplay.getPose and VRDisplay.getFrameData
+ * must return the same values until the next VRDisplay.submitFrame.
+ *
+ * mFrameInfo is marked dirty at the end of the frame or start of a new
+ * composition and lazily created here in order to receive mid-frame
+ * pose-prediction updates while still ensuring conformance to the WebVR spec
+ * requirements.
+ *
+ * If we are not presenting WebVR content, the frame will never end and we should
+ * return the latest frame data always.
+ */
+ if (mFrameInfo.IsDirty() || !mPresentation) {
+ gfx::VRHMDSensorState state = mClient->GetSensorState();
+ const gfx::VRDisplayInfo& info = mClient->GetDisplayInfo();
+ mFrameInfo.Update(info, state, mDepthNear, mDepthFar);
+ }
+}
+
+bool
+VRDisplay::GetFrameData(VRFrameData& aFrameData)
+{
+ UpdateFrameInfo();
+ aFrameData.Update(mFrameInfo);
+ return true;
+}
+
+already_AddRefed<VRPose>
+VRDisplay::GetPose()
+{
+ UpdateFrameInfo();
+ RefPtr<VRPose> obj = new VRPose(GetParentObject(), mFrameInfo.mVRState);
+
+ return obj.forget();
+}
+
+void
+VRDisplay::ResetPose()
+{
+ mClient->ZeroSensor();
+}
+
+already_AddRefed<Promise>
+VRDisplay::RequestPresent(const nsTArray<VRLayer>& aLayers, ErrorResult& aRv)
+{
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<Promise> promise = Promise::Create(global, aRv);
+ NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
+
+ nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+ NS_ENSURE_TRUE(obs, nullptr);
+
+ if (mClient->GetIsPresenting()) {
+ // Only one presentation allowed per VRDisplay
+ // on a first-come-first-serve basis.
+ promise->MaybeRejectWithUndefined();
+ } else {
+ mPresentation = mClient->BeginPresentation(aLayers);
+ mFrameInfo.Clear();
+
+ nsresult rv = obs->AddObserver(this, "inner-window-destroyed", false);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ mPresentation = nullptr;
+ promise->MaybeRejectWithUndefined();
+ } else {
+ promise->MaybeResolve(JS::UndefinedHandleValue);
+ }
+ }
+ return promise.forget();
+}
+
+NS_IMETHODIMP
+VRDisplay::Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aData)
+{
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (strcmp(aTopic, "inner-window-destroyed") == 0) {
+ nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
+ NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE);
+
+ uint64_t innerID;
+ nsresult rv = wrapper->GetData(&innerID);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!GetOwner() || GetOwner()->WindowID() == innerID) {
+ ExitPresentInternal();
+ }
+
+ return NS_OK;
+ }
+
+ // This should not happen.
+ return NS_ERROR_FAILURE;
+}
+
+already_AddRefed<Promise>
+VRDisplay::ExitPresent(ErrorResult& aRv)
+{
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetParentObject());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+
+ RefPtr<Promise> promise = Promise::Create(global, aRv);
+ NS_ENSURE_TRUE(!aRv.Failed(), nullptr);
+
+ if (!IsPresenting()) {
+ // We can not exit a presentation outside of the context that
+ // started the presentation.
+ promise->MaybeRejectWithUndefined();
+ } else {
+ promise->MaybeResolve(JS::UndefinedHandleValue);
+ ExitPresentInternal();
+ }
+
+ return promise.forget();
+}
+
+void
+VRDisplay::ExitPresentInternal()
+{
+ mPresentation = nullptr;
+}
+
+void
+VRDisplay::GetLayers(nsTArray<VRLayer>& result)
+{
+ if (mPresentation) {
+ mPresentation->GetDOMLayers(result);
+ } else {
+ result = nsTArray<VRLayer>();
+ }
+}
+
+void
+VRDisplay::SubmitFrame()
+{
+ if (mPresentation) {
+ mPresentation->SubmitFrame();
+ }
+ mFrameInfo.Clear();
+}
+
+int32_t
+VRDisplay::RequestAnimationFrame(FrameRequestCallback& aCallback,
+ErrorResult& aError)
+{
+ gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
+
+ int32_t handle;
+ aError = vm->ScheduleFrameRequestCallback(aCallback, &handle);
+ return handle;
+}
+
+void
+VRDisplay::CancelAnimationFrame(int32_t aHandle, ErrorResult& aError)
+{
+ gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
+ vm->CancelFrameRequestCallback(aHandle);
+}
+
+
+bool
+VRDisplay::IsPresenting() const
+{
+ // IsPresenting returns true only if this Javascript context is presenting
+ // and will return false if another context is presenting.
+ return mPresentation != nullptr;
+}
+
+bool
+VRDisplay::IsConnected() const
+{
+ return mClient->GetIsConnected();
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(VRDisplay, DOMEventTargetHelper, mCapabilities, mStageParameters)
+
+NS_IMPL_ADDREF_INHERITED(VRDisplay, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(VRDisplay, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(VRDisplay)
+NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, DOMEventTargetHelper)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(VRFrameData)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(VRFrameData)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent, mPose)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->mLeftProjectionMatrix = nullptr;
+ tmp->mLeftViewMatrix = nullptr;
+ tmp->mRightProjectionMatrix = nullptr;
+ tmp->mRightViewMatrix = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(VRFrameData)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent, mPose)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(VRFrameData)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mLeftProjectionMatrix)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mLeftViewMatrix)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mRightProjectionMatrix)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mRightViewMatrix)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(VRFrameData, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(VRFrameData, Release)
+
+VRFrameData::VRFrameData(nsISupports* aParent)
+ : mParent(aParent)
+ , mLeftProjectionMatrix(nullptr)
+ , mLeftViewMatrix(nullptr)
+ , mRightProjectionMatrix(nullptr)
+ , mRightViewMatrix(nullptr)
+{
+ mozilla::HoldJSObjects(this);
+ mPose = new VRPose(aParent);
+}
+
+VRFrameData::~VRFrameData()
+{
+ mozilla::DropJSObjects(this);
+}
+
+/* static */ already_AddRefed<VRFrameData>
+VRFrameData::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
+{
+ RefPtr<VRFrameData> obj = new VRFrameData(aGlobal.GetAsSupports());
+ return obj.forget();
+}
+
+JSObject*
+VRFrameData::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto)
+{
+ return VRFrameDataBinding::Wrap(aCx, this, aGivenProto);
+}
+
+VRPose*
+VRFrameData::Pose()
+{
+ return mPose;
+}
+
+void
+VRFrameData::LazyCreateMatrix(JS::Heap<JSObject*>& aArray, gfx::Matrix4x4& aMat, JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval, ErrorResult& aRv)
+{
+ if (!aArray) {
+ // Lazily create the Float32Array
+ aArray = dom::Float32Array::Create(aCx, this, 16, aMat.components);
+ if (!aArray) {
+ aRv.NoteJSContextException(aCx);
+ return;
+ }
+ }
+ if (aArray) {
+ JS::ExposeObjectToActiveJS(aArray);
+ }
+ aRetval.set(aArray);
+}
+
+double
+VRFrameData::Timestamp() const
+{
+ // Converting from seconds to milliseconds
+ return mFrameInfo.mVRState.timestamp * 1000.0f;
+}
+
+void
+VRFrameData::GetLeftProjectionMatrix(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ LazyCreateMatrix(mLeftProjectionMatrix, mFrameInfo.mLeftProjection, aCx,
+ aRetval, aRv);
+}
+
+void
+VRFrameData::GetLeftViewMatrix(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ LazyCreateMatrix(mLeftViewMatrix, mFrameInfo.mLeftView, aCx, aRetval, aRv);
+}
+
+void
+VRFrameData::GetRightProjectionMatrix(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ LazyCreateMatrix(mRightProjectionMatrix, mFrameInfo.mRightProjection, aCx,
+ aRetval, aRv);
+}
+
+void
+VRFrameData::GetRightViewMatrix(JSContext* aCx,
+ JS::MutableHandle<JSObject*> aRetval,
+ ErrorResult& aRv)
+{
+ LazyCreateMatrix(mRightViewMatrix, mFrameInfo.mRightView, aCx, aRetval, aRv);
+}
+
+void
+VRFrameData::Update(const VRFrameInfo& aFrameInfo)
+{
+ mFrameInfo = aFrameInfo;
+
+ mLeftProjectionMatrix = nullptr;
+ mLeftViewMatrix = nullptr;
+ mRightProjectionMatrix = nullptr;
+ mRightViewMatrix = nullptr;
+
+ mPose = new VRPose(GetParentObject(), mFrameInfo.mVRState);
+}
+
+void
+VRFrameInfo::Update(const gfx::VRDisplayInfo& aInfo,
+ const gfx::VRHMDSensorState& aState,
+ float aDepthNear,
+ float aDepthFar)
+{
+ mVRState = aState;
+
+ gfx::Quaternion qt;
+ if (mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Orientation) {
+ qt.x = mVRState.orientation[0];
+ qt.y = mVRState.orientation[1];
+ qt.z = mVRState.orientation[2];
+ qt.w = mVRState.orientation[3];
+ }
+ gfx::Point3D pos;
+ if (mVRState.flags & gfx::VRDisplayCapabilityFlags::Cap_Position) {
+ pos.x = -mVRState.position[0];
+ pos.y = -mVRState.position[1];
+ pos.z = -mVRState.position[2];
+ }
+ gfx::Matrix4x4 matHead;
+ matHead.SetRotationFromQuaternion(qt);
+ matHead.PreTranslate(pos);
+
+ mLeftView = matHead;
+ mLeftView.PostTranslate(-aInfo.mEyeTranslation[gfx::VRDisplayInfo::Eye_Left]);
+
+ mRightView = matHead;
+ mRightView.PostTranslate(-aInfo.mEyeTranslation[gfx::VRDisplayInfo::Eye_Right]);
+
+ // Avoid division by zero within ConstructProjectionMatrix
+ const float kEpsilon = 0.00001f;
+ if (fabs(aDepthFar - aDepthNear) < kEpsilon) {
+ aDepthFar = aDepthNear + kEpsilon;
+ }
+
+ const gfx::VRFieldOfView leftFOV = aInfo.mEyeFOV[gfx::VRDisplayInfo::Eye_Left];
+ mLeftProjection = leftFOV.ConstructProjectionMatrix(aDepthNear, aDepthFar, true);
+ const gfx::VRFieldOfView rightFOV = aInfo.mEyeFOV[gfx::VRDisplayInfo::Eye_Right];
+ mRightProjection = rightFOV.ConstructProjectionMatrix(aDepthNear, aDepthFar, true);
+}
+
+VRFrameInfo::VRFrameInfo()
+{
+ mVRState.Clear();
+}
+
+bool
+VRFrameInfo::IsDirty()
+{
+ return mVRState.timestamp == 0;
+}
+
+void
+VRFrameInfo::Clear()
+{
+ mVRState.Clear();
+}
+
+} // namespace dom
+} // namespace mozilla