#include "config.h"
#include "VRFrameData.h"
#include "VREyeParameters.h"
#include "VRPlatformDisplay.h"
#include "VRPose.h"
#include <JavaScriptCore/TypedArrayInlines.h>
namespace WebCore {
VRFrameData::VRFrameData()
: m_pose(VRPose::create())
{
}
static Ref<Float32Array> matrixToArray(const TransformationMatrix& matrix)
{
auto columnMajorMatrix = matrix.toColumnMajorFloatArray();
return Float32Array::create(columnMajorMatrix.data(), 16);
}
Ref<Float32Array> VRFrameData::leftProjectionMatrix() const
{
return matrixToArray(m_leftProjectionMatrix);
}
Ref<Float32Array> VRFrameData::leftViewMatrix() const
{
return matrixToArray(m_leftViewMatrix);
}
Ref<Float32Array> VRFrameData::rightProjectionMatrix() const
{
return matrixToArray(m_rightProjectionMatrix);
}
Ref<Float32Array> VRFrameData::rightViewMatrix() const
{
return matrixToArray(m_rightViewMatrix);
}
const VRPose& VRFrameData::pose() const
{
return m_pose;
}
static TransformationMatrix projectionMatrixFromFieldOfView(const VRFieldOfView& fov, double depthNear, double depthFar)
{
double upTan = tan(deg2rad(fov.upDegrees()));
double downTan = tan(deg2rad(fov.downDegrees()));
double leftTan = tan(deg2rad(fov.leftDegrees()));
double rightTan = tan(deg2rad(fov.rightDegrees()));
double xScale = 2 / (leftTan + rightTan);
double yScale = 2 / (upTan + downTan);
TransformationMatrix projectionMatrix;
projectionMatrix.setM11(xScale);
projectionMatrix.setM22(yScale);
projectionMatrix.setM32((upTan - downTan) * yScale * 0.5);
projectionMatrix.setM31(-((leftTan - rightTan) * xScale * 0.5));
projectionMatrix.setM33((depthNear + depthFar) / (depthNear - depthFar));
projectionMatrix.setM34(-1);
projectionMatrix.setM43((2 * depthFar * depthNear) / (depthNear - depthFar));
projectionMatrix.setM44(0);
return projectionMatrix;
}
static TransformationMatrix rotationMatrixFromQuaternion(const VRPlatformTrackingInfo::Quaternion& quaternion)
{
double magnitude = (quaternion.x * quaternion.x) + (quaternion.y * quaternion.y) + (quaternion.z * quaternion.z) + (quaternion.w * quaternion.w);
VRPlatformTrackingInfo::Quaternion normalizedQuaternion(quaternion.x / magnitude, quaternion.y / magnitude, quaternion.z / magnitude, quaternion.w / magnitude);
double x2 = normalizedQuaternion.x * normalizedQuaternion.x;
double y2 = normalizedQuaternion.y * normalizedQuaternion.y;
double z2 = normalizedQuaternion.z * normalizedQuaternion.z;
double w2 = normalizedQuaternion.w * normalizedQuaternion.w;
double xy = normalizedQuaternion.x * normalizedQuaternion.y;
double zw = normalizedQuaternion.z * normalizedQuaternion.w;
double xz = normalizedQuaternion.x * normalizedQuaternion.z;
double yw = normalizedQuaternion.y * normalizedQuaternion.w;
double yz = normalizedQuaternion.y * normalizedQuaternion.z;
double xw = normalizedQuaternion.x * normalizedQuaternion.w;
return TransformationMatrix(
x2 - y2 - z2 + w2, 2.0 * (xy - zw), 2.0 * (xz + yw), 0,
2.0 * (xy + zw), -x2 + y2 - z2 + w2, 2.0 * (yz - xw), 0,
2.0 * (xz - yw), 2.0 * (yz + xw), -x2 - y2 + z2 + w2, 0,
0, 0, 0, 1);
}
static void applyHeadToEyeTransform(TransformationMatrix& matrix, const FloatPoint3D& translation)
{
matrix.setM41(matrix.m41() - translation.x());
matrix.setM42(matrix.m42() - translation.y());
matrix.setM43(matrix.m43() - translation.z());
}
void VRFrameData::update(const VRPlatformTrackingInfo& trackingInfo, const VREyeParameters& leftEye, const VREyeParameters& rightEye, double depthNear, double depthFar)
{
m_leftProjectionMatrix = projectionMatrixFromFieldOfView(leftEye.fieldOfView(), depthNear, depthFar);
m_rightProjectionMatrix = projectionMatrixFromFieldOfView(rightEye.fieldOfView(), depthNear, depthFar);
m_timestamp = trackingInfo.timestamp;
m_pose->update(trackingInfo);
auto rotationMatrix = rotationMatrixFromQuaternion(trackingInfo.orientation.valueOr(VRPlatformTrackingInfo::Quaternion(0, 0, 0, 1)));
FloatPoint3D position = trackingInfo.position.valueOr(FloatPoint3D(0, 0, 0));
rotationMatrix.translate3d(-position.x(), -position.y(), -position.z());
m_leftViewMatrix = rotationMatrix;
applyHeadToEyeTransform(m_leftViewMatrix, leftEye.rawOffset());
m_rightViewMatrix = rotationMatrix;
applyHeadToEyeTransform(m_rightViewMatrix, rightEye.rawOffset());
}
}