Changeset 230428 in webkit


Ignore:
Timestamp:
Apr 9, 2018 7:40:51 AM (6 years ago)
Author:
svillar@igalia.com
Message:

[OpenVR][WebVR] Retrieve FrameData in WebVR's rAF
​https://bugs.webkit.org/show_bug.cgi?id=184265

Reviewed by Žan Doberšek.

VRFrameData contains all the required information to properly render a VR scene like view
and projection matrices, pose data (position & orientation) and linear & angular velocity
among others. The getFrameData() call must be issued inside a WebVR's own
requestAnimationFrame.

  • Modules/webvr/VRDisplay.cpp:

(WebCore::VRDisplay::getFrameData const):
(WebCore::VRDisplay::getPose const):
(WebCore::VRDisplay::requestAnimationFrame):
(WebCore::VRDisplay::cancelAnimationFrame):

  • Modules/webvr/VRDisplay.h:
  • Modules/webvr/VREyeParameters.h:

(WebCore::VREyeParameters::rawOffset const): Required to compute view matrices.

  • Modules/webvr/VRFrameData.cpp:

(WebCore::matrixToArray):
(WebCore::VRFrameData::leftProjectionMatrix const):
(WebCore::VRFrameData::leftViewMatrix const):
(WebCore::VRFrameData::rightProjectionMatrix const):
(WebCore::VRFrameData::rightViewMatrix const):
(WebCore::projectionMatrixFromFieldOfView):
(WebCore::rotationMatrixFromQuaternion):
(WebCore::applyHeadToEyeTransform):
(WebCore::VRFrameData::update):
(WebCore::VRFrameData::timestamp const): Deleted.

  • Modules/webvr/VRFrameData.h:

(WebCore::VRFrameData::timestamp const):

  • Modules/webvr/VRPose.cpp:

(WebCore::optionalFloat3ToJSCArray):
(WebCore::VRPose::position const):
(WebCore::VRPose::linearVelocity const):
(WebCore::VRPose::linearAcceleration const):
(WebCore::VRPose::orientation const):
(WebCore::VRPose::angularVelocity const):
(WebCore::VRPose::angularAcceleration const):

  • Modules/webvr/VRPose.h:

(WebCore::VRPose::create):
(WebCore::VRPose::update):
(WebCore::VRPose::VRPose):

  • platform/vr/VRPlatformDisplay.h:

(WebCore::VRPlatformTrackingInfo::Quaternion::Quaternion):
(WebCore::VRPlatformTrackingInfo::Quaternion::conjugate):
(WebCore::VRPlatformTrackingInfo::Quaternion::operator*):
(WebCore::VRPlatformTrackingInfo::Float3::Float3): Just a group of 3 floats used to store
both velocity and acceleration in a format which is very convenient to later generate JSC
arrays.
(WebCore::VRPlatformTrackingInfo::clear):

  • platform/vr/openvr/VRPlatformDisplayOpenVR.cpp:

(WebCore::VRPlatformDisplayOpenVR::VRPlatformDisplayOpenVR):
(WebCore::rotationMatrixToQuaternion):
(WebCore::VRPlatformDisplayOpenVR::getTrackingInfo):

  • platform/vr/openvr/VRPlatformDisplayOpenVR.h:
Location:
trunk/Source/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r230390 r230428  
     12018-04-03  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [OpenVR][WebVR] Retrieve FrameData in WebVR's rAF
     4        https://bugs.webkit.org/show_bug.cgi?id=184265
     5
     6        Reviewed by Žan Doberšek.
     7
     8        VRFrameData contains all the required information to properly render a VR scene like view
     9        and projection matrices, pose data (position & orientation) and linear & angular velocity
     10        among others. The getFrameData() call must be issued inside a WebVR's own
     11        requestAnimationFrame.
     12
     13        * Modules/webvr/VRDisplay.cpp:
     14        (WebCore::VRDisplay::getFrameData const):
     15        (WebCore::VRDisplay::getPose const):
     16        (WebCore::VRDisplay::requestAnimationFrame):
     17        (WebCore::VRDisplay::cancelAnimationFrame):
     18        * Modules/webvr/VRDisplay.h:
     19        * Modules/webvr/VREyeParameters.h:
     20        (WebCore::VREyeParameters::rawOffset const): Required to compute view matrices.
     21        * Modules/webvr/VRFrameData.cpp:
     22        (WebCore::matrixToArray):
     23        (WebCore::VRFrameData::leftProjectionMatrix const):
     24        (WebCore::VRFrameData::leftViewMatrix const):
     25        (WebCore::VRFrameData::rightProjectionMatrix const):
     26        (WebCore::VRFrameData::rightViewMatrix const):
     27        (WebCore::projectionMatrixFromFieldOfView):
     28        (WebCore::rotationMatrixFromQuaternion):
     29        (WebCore::applyHeadToEyeTransform):
     30        (WebCore::VRFrameData::update):
     31        (WebCore::VRFrameData::timestamp const): Deleted.
     32        * Modules/webvr/VRFrameData.h:
     33        (WebCore::VRFrameData::timestamp const):
     34        * Modules/webvr/VRPose.cpp:
     35        (WebCore::optionalFloat3ToJSCArray):
     36        (WebCore::VRPose::position const):
     37        (WebCore::VRPose::linearVelocity const):
     38        (WebCore::VRPose::linearAcceleration const):
     39        (WebCore::VRPose::orientation const):
     40        (WebCore::VRPose::angularVelocity const):
     41        (WebCore::VRPose::angularAcceleration const):
     42        * Modules/webvr/VRPose.h:
     43        (WebCore::VRPose::create):
     44        (WebCore::VRPose::update):
     45        (WebCore::VRPose::VRPose):
     46        * platform/vr/VRPlatformDisplay.h:
     47        (WebCore::VRPlatformTrackingInfo::Quaternion::Quaternion):
     48        (WebCore::VRPlatformTrackingInfo::Quaternion::conjugate):
     49        (WebCore::VRPlatformTrackingInfo::Quaternion::operator*):
     50        (WebCore::VRPlatformTrackingInfo::Float3::Float3): Just a group of 3 floats used to store
     51        both velocity and acceleration in a format which is very convenient to later generate JSC
     52        arrays.
     53        (WebCore::VRPlatformTrackingInfo::clear):
     54        * platform/vr/openvr/VRPlatformDisplayOpenVR.cpp:
     55        (WebCore::VRPlatformDisplayOpenVR::VRPlatformDisplayOpenVR):
     56        (WebCore::rotationMatrixToQuaternion):
     57        (WebCore::VRPlatformDisplayOpenVR::getTrackingInfo):
     58        * platform/vr/openvr/VRPlatformDisplayOpenVR.h:
     59
    1602018-04-09  Michael Catanzaro  <mcatanzaro@igalia.com>
    261

  • trunk/Source/WebCore/Modules/webvr/VRDisplay.cpp

    r229089 r230428  
    2727#include "VRDisplay.h"
    2828
     29#include "Chrome.h"
     30#include "Page.h"
     31#include "ScriptedAnimationController.h"
    2932#include "VRDisplayCapabilities.h"
    3033#include "VREyeParameters.h"
     34#include "VRFrameData.h"
    3135#include "VRLayerInit.h"
    3236#include "VRPlatformDisplay.h"
    … …  
    8690}
    8791
    88 bool VRDisplay::getFrameData(VRFrameData&) const
     92bool VRDisplay::getFrameData(VRFrameData& frameData) const
    8993{
    90     return false;
     94    if (!m_capabilities->hasPosition() || !m_capabilities->hasOrientation())
     95        return false;
     96
     97    // FIXME: ensure that this is only called inside WebVR's rAF.
     98    frameData.update(m_display->getTrackingInfo(), getEyeParameters(VREye::Left), getEyeParameters(VREye::Right), m_depthNear, m_depthFar);
     99    return true;
    91100}
    92101
    93102Ref<VRPose> VRDisplay::getPose() const
    94103{
    95     return VRPose::create();
     104    return VRPose::create(m_display->getTrackingInfo());
    96105}
    97106
    … …  
    100109}
    101110
    102 long VRDisplay::requestAnimationFrame(Ref<RequestAnimationFrameCallback>&&)
     111uint32_t VRDisplay::requestAnimationFrame(Ref<RequestAnimationFrameCallback>&& callback)
    103112{
    104     return 0;
     113    if (!m_scriptedAnimationController) {
     114        auto* document = downcast<Document>(scriptExecutionContext());
     115#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     116        // FIXME: Get the display id of the HMD as it should use the HMD native refresh rate.
     117        PlatformDisplayID displayID = document->page() ? document->page()->chrome().displayID() : 0;
     118        m_scriptedAnimationController = ScriptedAnimationController::create(*document, displayID);
     119#else
     120        m_scriptedAnimationController = ScriptedAnimationController::create(*document, 0);
     121#endif
     122    }
     123
     124    return m_scriptedAnimationController->registerCallback(WTFMove(callback));
    105125}
    106126
    107 void VRDisplay::cancelAnimationFrame(unsigned)
     127void VRDisplay::cancelAnimationFrame(uint32_t id)
    108128{
     129    if (!m_scriptedAnimationController)
     130        return;
     131
     132    m_scriptedAnimationController->cancelCallback(id);
    109133}
    110134

  • trunk/Source/WebCore/Modules/webvr/VRDisplay.h

    r229014 r230428  
    3535
    3636class RequestAnimationFrameCallback;
     37class ScriptedAnimationController;
    3738class VRDisplayCapabilities;
    3839class VREyeParameters;
    … …  
    7374    void setDepthFar(double depthFar) { m_depthFar = depthFar; }
    7475
    75     long requestAnimationFrame(Ref<RequestAnimationFrameCallback>&&);
    76     void cancelAnimationFrame(unsigned);
     76    uint32_t requestAnimationFrame(Ref<RequestAnimationFrameCallback>&&);
     77    void cancelAnimationFrame(uint32_t);
    7778
    7879    void requestPresent(const Vector<VRLayerInit>&, Ref<DeferredPromise>&&);
    … …  
    112113    double m_depthNear { 0.01 }; // Default value from the specs.
    113114    double m_depthFar { 10000 }; // Default value from the specs.
     115
     116    RefPtr<ScriptedAnimationController> m_scriptedAnimationController;
    114117};
    115118

  • trunk/Source/WebCore/Modules/webvr/VREyeParameters.h

    r228819 r230428  
    4444
    4545    Ref<Float32Array> offset() const;
     46    const FloatPoint3D& rawOffset() const { return m_offset; }
    4647
    4748    const VRFieldOfView& fieldOfView() const;

  • trunk/Source/WebCore/Modules/webvr/VRFrameData.cpp

    r221966 r230428  
    2626#include "VRFrameData.h"
    2727
     28#include "VREyeParameters.h"
     29#include "VRPlatformDisplay.h"
    2830#include "VRPose.h"
    2931
    … …  
    3537}
    3638
    37 double VRFrameData::timestamp() const
     39static Ref<Float32Array> matrixToArray(const TransformationMatrix& matrix)
    3840{
    39     return 0;
     41    TransformationMatrix::FloatMatrix4 columnMajorMatrix;
     42    matrix.toColumnMajorFloatArray(columnMajorMatrix);
     43    return Float32Array::create(columnMajorMatrix, 16).releaseNonNull();
    4044}
    4145
    42 Float32Array* VRFrameData::leftProjectionMatrix() const
     46Ref<Float32Array> VRFrameData::leftProjectionMatrix() const
    4347{
    44     return nullptr;
     48    return matrixToArray(m_leftProjectionMatrix);
    4549}
    4650
    47 Float32Array* VRFrameData::leftViewMatrix() const
     51Ref<Float32Array> VRFrameData::leftViewMatrix() const
    4852{
    49     return nullptr;
     53    return matrixToArray(m_leftViewMatrix);
    5054}
    5155
    52 Float32Array* VRFrameData::rightProjectionMatrix() const
     56Ref<Float32Array> VRFrameData::rightProjectionMatrix() const
    5357{
    54     return nullptr;
     58    return matrixToArray(m_rightProjectionMatrix);
    5559}
    5660
    57 Float32Array* VRFrameData::rightViewMatrix() const
     61Ref<Float32Array> VRFrameData::rightViewMatrix() const
    5862{
    59     return nullptr;
     63    return matrixToArray(m_rightViewMatrix);
    6064}
    6165
    … …  
    6569}
    6670
     71static TransformationMatrix projectionMatrixFromFieldOfView(const VRFieldOfView& fov, double depthNear, double depthFar)
     72{
     73    double upTan = tan(deg2rad(fov.upDegrees()));
     74    double downTan = tan(deg2rad(fov.downDegrees()));
     75    double leftTan = tan(deg2rad(fov.leftDegrees()));
     76    double rightTan = tan(deg2rad(fov.rightDegrees()));
     77
     78    double xScale = 2 / (leftTan + rightTan);
     79    double yScale = 2 / (upTan + downTan);
     80
     81    TransformationMatrix projectionMatrix;
     82    projectionMatrix.setM11(xScale);
     83    projectionMatrix.setM22(yScale);
     84    projectionMatrix.setM32((upTan - downTan) * yScale * 0.5);
     85    projectionMatrix.setM31(-((leftTan - rightTan) * xScale * 0.5));
     86    projectionMatrix.setM33((depthNear + depthFar) / (depthNear - depthFar));
     87    projectionMatrix.setM34(-1);
     88    projectionMatrix.setM43((2 * depthFar * depthNear) / (depthNear - depthFar));
     89    projectionMatrix.setM44(0);
     90
     91    return projectionMatrix;
     92}
     93
     94// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/index.htm
     95static TransformationMatrix rotationMatrixFromQuaternion(const VRPlatformTrackingInfo::Quaternion& quaternion)
     96{
     97    double magnitude = (quaternion.x * quaternion.x) + (quaternion.y * quaternion.y) + (quaternion.z * quaternion.z) + (quaternion.w * quaternion.w);
     98    VRPlatformTrackingInfo::Quaternion normalizedQuaternion(quaternion.x / magnitude, quaternion.y / magnitude, quaternion.z / magnitude, quaternion.w / magnitude);
     99    double x2 = normalizedQuaternion.x * normalizedQuaternion.x;
     100    double y2 = normalizedQuaternion.y * normalizedQuaternion.y;
     101    double z2 = normalizedQuaternion.z * normalizedQuaternion.z;
     102    double w2 = normalizedQuaternion.w * normalizedQuaternion.w;
     103    double xy = normalizedQuaternion.x * normalizedQuaternion.y;
     104    double zw = normalizedQuaternion.z * normalizedQuaternion.w;
     105    double xz = normalizedQuaternion.x * normalizedQuaternion.z;
     106    double yw = normalizedQuaternion.y * normalizedQuaternion.w;
     107    double yz = normalizedQuaternion.y * normalizedQuaternion.z;
     108    double xw = normalizedQuaternion.x * normalizedQuaternion.w;
     109
     110    return TransformationMatrix(
     111        x2 - y2 - z2 + w2, 2.0 * (xy - zw), 2.0 * (xz + yw), 0,
     112        2.0 * (xy + zw), -x2 + y2 - z2 + w2, 2.0 * (yz - xw), 0,
     113        2.0 * (xz - yw), 2.0 * (yz + xw), -x2 - y2 + z2 + w2, 0,
     114        0, 0, 0, 1);
     115}
     116
     117static void applyHeadToEyeTransform(TransformationMatrix& matrix, const FloatPoint3D& translation)
     118{
     119    matrix.setM41(matrix.m41() - translation.x());
     120    matrix.setM42(matrix.m42() - translation.y());
     121    matrix.setM43(matrix.m43() - translation.z());
     122}
     123
     124void VRFrameData::update(const VRPlatformTrackingInfo& trackingInfo, const VREyeParameters& leftEye, const VREyeParameters& rightEye, double depthNear, double depthFar)
     125{
     126    m_leftProjectionMatrix = projectionMatrixFromFieldOfView(leftEye.fieldOfView(), depthNear, depthFar);
     127    m_rightProjectionMatrix = projectionMatrixFromFieldOfView(rightEye.fieldOfView(), depthNear, depthFar);
     128
     129    m_timestamp = trackingInfo.timestamp;
     130    m_pose->update(trackingInfo);
     131
     132    auto rotationMatrix = rotationMatrixFromQuaternion(trackingInfo.orientation.value_or(VRPlatformTrackingInfo::Quaternion(0, 0, 0, 1)));
     133    FloatPoint3D position = trackingInfo.position.value_or(FloatPoint3D(0, 0, 0));
     134    rotationMatrix.translate3d(-position.x(), -position.y(), -position.z());
     135
     136    m_leftViewMatrix = rotationMatrix;
     137    applyHeadToEyeTransform(m_leftViewMatrix, leftEye.rawOffset());
     138
     139    m_rightViewMatrix = rotationMatrix;
     140    applyHeadToEyeTransform(m_rightViewMatrix, rightEye.rawOffset());
     141}
     142
    67143} // namespace WebCore

  • trunk/Source/WebCore/Modules/webvr/VRFrameData.h

    r228218 r230428  
    2525#pragma once
    2626
     27#include "TransformationMatrix.h"
    2728#include <JavaScriptCore/Float32Array.h>
    2829#include <wtf/RefCounted.h>
    … …  
    3031namespace WebCore {
    3132
     33class VREyeParameters;
    3234class VRPose;
     35struct VRPlatformTrackingInfo;
    3336
    3437class VRFrameData : public RefCounted<VRFrameData> {
    … …  
    3942    }
    4043
    41     double timestamp() const;
     44    double timestamp() const { return m_timestamp; }
    4245
    43     Float32Array* leftProjectionMatrix() const;
    44     Float32Array* leftViewMatrix() const;
     46    Ref<Float32Array> leftProjectionMatrix() const;
     47    Ref<Float32Array> leftViewMatrix() const;
    4548
    46     Float32Array* rightProjectionMatrix() const;
    47     Float32Array* rightViewMatrix() const;
     49    Ref<Float32Array> rightProjectionMatrix() const;
     50    Ref<Float32Array> rightViewMatrix() const;
    4851
    4952    const VRPose& pose() const;
     53
     54    void update(const VRPlatformTrackingInfo&, const VREyeParameters& leftEye, const VREyeParameters& rightEye, double depthNear, double depthFar);
    5055
    5156private:
    5257    VRFrameData();
    5358
     59    double m_timestamp { 0 };
    5460    Ref<VRPose> m_pose;
     61    TransformationMatrix m_leftProjectionMatrix;
     62    TransformationMatrix m_rightProjectionMatrix;
     63    TransformationMatrix m_leftViewMatrix;
     64    TransformationMatrix m_rightViewMatrix;
    5565};
    5666

  • trunk/Source/WebCore/Modules/webvr/VRPose.cpp

    r221966 r230428  
    2828namespace WebCore {
    2929
    30 VRPose::VRPose() = default;
     30static RefPtr<Float32Array> optionalFloat3ToJSCArray(const std::optional<VRPlatformTrackingInfo::Float3>& data)
     31{
     32    if (!data)
     33        return nullptr;
    3134
    32 Float32Array* VRPose::position() const
    33 {
    34     return nullptr;
     35    return Float32Array::create(data->data, 3).releaseNonNull();
    3536}
    3637
    37 Float32Array* VRPose::linearVelocity() const
     38RefPtr<Float32Array> VRPose::position() const
    3839{
    39     return nullptr;
     40    if (!m_trackingInfo.position)
     41        return nullptr;
     42
     43    auto& position = *m_trackingInfo.position;
     44    float positionData[3] = { position.x(), position.y(), position.z() };
     45    return Float32Array::create(positionData, 3).releaseNonNull();
    4046}
    4147
    42 Float32Array* VRPose::linearAcceleration() const
     48RefPtr<Float32Array> VRPose::linearVelocity() const
    4349{
    44     return nullptr;
     50    return optionalFloat3ToJSCArray(m_trackingInfo.linearVelocity);
    4551}
    4652
    47 Float32Array* VRPose::orientation() const
     53RefPtr<Float32Array> VRPose::linearAcceleration() const
    4854{
    49     return nullptr;
     55    return optionalFloat3ToJSCArray(m_trackingInfo.linearAcceleration);
    5056}
    5157
    52 Float32Array* VRPose::angularVelocity() const
     58RefPtr<Float32Array> VRPose::orientation() const
    5359{
    54     return nullptr;
     60    if (!m_trackingInfo.orientation)
     61        return nullptr;
     62
     63    auto& orientation = *m_trackingInfo.orientation;
     64    float orientationData[4] = { orientation.x, orientation.y, orientation.z, orientation.w };
     65    return Float32Array::create(orientationData, 4).releaseNonNull();
    5566}
    5667
    57 Float32Array* VRPose::angularAcceleration() const
     68RefPtr<Float32Array> VRPose::angularVelocity() const
    5869{
    59     return nullptr;
     70    return optionalFloat3ToJSCArray(m_trackingInfo.angularVelocity);
     71}
     72
     73RefPtr<Float32Array> VRPose::angularAcceleration() const
     74{
     75    return optionalFloat3ToJSCArray(m_trackingInfo.angularAcceleration);
    6076}
    6177

  • trunk/Source/WebCore/Modules/webvr/VRPose.h

    r228218 r230428  
    2525#pragma once
    2626
     27#include "VRPlatformDisplay.h"
    2728#include <JavaScriptCore/Float32Array.h>
    2829#include <wtf/RefCounted.h>
    … …  
    3738    }
    3839
    39     Float32Array* position() const;
    40     Float32Array* linearVelocity() const;
    41     Float32Array* linearAcceleration() const;
     40    static Ref<VRPose> create(const VRPlatformTrackingInfo& trackingInfo)
     41    {
     42        return adoptRef(*new VRPose(trackingInfo));
     43    }
    4244
    43     Float32Array* orientation() const;
    44     Float32Array* angularVelocity() const;
    45     Float32Array* angularAcceleration() const;
     45    RefPtr<Float32Array> position() const;
     46    RefPtr<Float32Array> linearVelocity() const;
     47    RefPtr<Float32Array> linearAcceleration() const;
     48
     49    RefPtr<Float32Array> orientation() const;
     50    RefPtr<Float32Array> angularVelocity() const;
     51    RefPtr<Float32Array> angularAcceleration() const;
     52
     53    void update(const VRPlatformTrackingInfo& trackingInfo) { m_trackingInfo = trackingInfo; };
    4654
    4755private:
    48     VRPose();
     56    VRPose() = default;
     57
     58    VRPose(const VRPlatformTrackingInfo& trackingInfo)
     59        : m_trackingInfo(trackingInfo)
     60    {
     61    }
     62
     63    VRPlatformTrackingInfo m_trackingInfo;
    4964};
    5065

  • trunk/Source/WebCore/platform/vr/VRPlatformDisplay.h

    r229089 r230428  
    104104};
    105105
     106struct VRPlatformTrackingInfo {
     107    struct Quaternion {
     108        Quaternion()
     109            : x(0), y(0), z(0), w(1) { }
     110
     111        Quaternion(float x, float y, float z, float w)
     112            : x(x), y(y), z(z), w(w) { }
     113
     114        Quaternion& conjugate()
     115        {
     116            x *= -1;
     117            y *= -1;
     118            z *= -1;
     119            return *this;
     120        }
     121
     122        Quaternion& operator*(float factor)
     123        {
     124            x *= factor;
     125            y *= factor;
     126            z *= factor;
     127            w *= factor;
     128            return *this;
     129        }
     130        float x, y, z, w;
     131    };
     132
     133    struct Float3 {
     134        Float3(float a, float b, float c)
     135            : data { a, b, c } { }
     136
     137        float data[3];
     138    };
     139
     140    void clear()
     141    {
     142        timestamp = 0;
     143        position = std::nullopt;
     144        orientation = std::nullopt;
     145        angularAcceleration = std::nullopt;
     146        angularVelocity = std::nullopt;
     147        linearAcceleration = std::nullopt;
     148        linearVelocity = std::nullopt;
     149    }
     150
     151    std::optional<Quaternion> orientation;
     152    std::optional<FloatPoint3D> position;
     153    std::optional<Float3> angularAcceleration;
     154    std::optional<Float3> angularVelocity;
     155    std::optional<Float3> linearAcceleration;
     156    std::optional<Float3> linearVelocity;
     157    double timestamp { 0 };
     158};
     159
    106160class VRPlatformDisplay {
    107161public:
    108162    virtual VRPlatformDisplayInfo getDisplayInfo() = 0;
     163    virtual VRPlatformTrackingInfo getTrackingInfo() = 0;
    109164    virtual ~VRPlatformDisplay() = default;
    110165

  • trunk/Source/WebCore/platform/vr/openvr/VRPlatformDisplayOpenVR.cpp

    r229089 r230428  
    5151    m_displayInfo.setCapabilityFlags(VRDisplayCapabilityFlag::None | VRDisplayCapabilityFlag::Position | VRDisplayCapabilityFlag::Orientation | VRDisplayCapabilityFlag::ExternalDisplay | VRDisplayCapabilityFlag::Present);
    5252
     53    m_compositor->SetTrackingSpace(vr::TrackingUniverseSeated);
     54
    5355    updateEyeParameters();
    5456    updateStageParameters();
    … …  
    100102}
    101103
     104// FIXME: we might want to generalize this function for other backends.
     105static VRPlatformTrackingInfo::Quaternion rotationMatrixToQuaternion(const float (&matrix)[3][4])
     106{
     107    // See https://d3cw3dd2w32x2b.cloudfront.net/wp-content/uploads/2015/01/matrix-to-quat.pdf.
     108    VRPlatformTrackingInfo::Quaternion quaternion;
     109    float trace;
     110    if (matrix[2][2] < 0) {
     111        if (matrix[0][0] > matrix[1][1]) {
     112            trace = 1 + matrix[0][0] - matrix[1][1] - matrix[2][2];
     113            quaternion = { trace, matrix[0][1]+matrix[1][0], matrix[2][0]+matrix[0][2], matrix[1][2] - matrix[2][1] };
     114        } else {
     115            trace = 1 - matrix[0][0] + matrix[1][1] - matrix[2][2];
     116            quaternion = { matrix[0][1]+matrix[1][0], trace, matrix[1][2]+matrix[2][1], matrix[2][0] - matrix[0][2] };
     117        }
     118    } else {
     119        if (matrix[0][0] < -matrix[1][1]) {
     120            trace = 1 - matrix[0][0] - matrix[1][1] + matrix[2][2];
     121            quaternion = { matrix[2][0]+matrix[0][2], matrix[1][2]+matrix[2][1], trace , matrix[0][1] - matrix[1][0] };
     122        } else {
     123            trace = 1 + matrix[0][0] + matrix[1][1] + matrix[2][2];
     124            quaternion = { matrix[1][2] - matrix[2][1], matrix[2][0] - matrix[0][2], matrix[0][1] - matrix[1][0], trace };
     125        }
     126    }
     127    return quaternion * (0.5 / sqrt(trace));
     128}
     129
     130VRPlatformTrackingInfo VRPlatformDisplayOpenVR::getTrackingInfo()
     131{
     132    vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount];
     133
     134    m_compositor->WaitGetPoses(nullptr, 0, poses, vr::k_unMaxTrackedDeviceCount);
     135
     136    m_trackingInfo.clear();
     137
     138    vr::Compositor_FrameTiming timing;
     139    timing.m_nSize = sizeof(vr::Compositor_FrameTiming);
     140    m_compositor->GetFrameTiming(&timing);
     141    m_trackingInfo.timestamp = timing.m_flSystemTimeInSeconds;
     142
     143    if (!poses[vr::k_unTrackedDeviceIndex_Hmd].bDeviceIsConnected
     144        || !poses[vr::k_unTrackedDeviceIndex_Hmd].bPoseIsValid
     145        || poses[vr::k_unTrackedDeviceIndex_Hmd].eTrackingResult != vr::TrackingResult_Running_OK) {
     146        // FIXME: Init some data maybe???.
     147        return m_trackingInfo;
     148    }
     149
     150    const auto& HMDPose = poses[vr::k_unTrackedDeviceIndex_Hmd];
     151    const auto& transform = HMDPose.mDeviceToAbsoluteTracking;
     152    m_trackingInfo.orientation = rotationMatrixToQuaternion(transform.m);
     153    m_trackingInfo.orientation->conjugate();
     154    m_trackingInfo.position = FloatPoint3D(transform.m[0][3], transform.m[1][3], transform.m[2][3]);
     155    m_trackingInfo.angularVelocity = VRPlatformTrackingInfo::Float3(HMDPose.vAngularVelocity.v[0], HMDPose.vAngularVelocity.v[1], HMDPose.vAngularVelocity.v[2]);
     156    m_trackingInfo.linearVelocity = VRPlatformTrackingInfo::Float3(HMDPose.vVelocity.v[0], HMDPose.vVelocity.v[1], HMDPose.vVelocity.v[2]);
     157
     158    return m_trackingInfo;
     159}
     160
    102161}; // namespace WebCore
    103162

  • trunk/Source/WebCore/platform/vr/openvr/VRPlatformDisplayOpenVR.h

    r229014 r230428  
    3535    ~VRPlatformDisplayOpenVR() = default;
    3636    VRPlatformDisplayInfo getDisplayInfo() override { return m_displayInfo; }
     37    VRPlatformTrackingInfo getTrackingInfo() override;
    3738
    3839private:
    … …  
    4849
    4950    VRPlatformDisplayInfo m_displayInfo;
     51    VRPlatformTrackingInfo m_trackingInfo;
    5052};
    5153
Note: See TracChangeset for help on using the changeset viewer.