Great question! Now that VREyeParameters.fieldOfView is deprecated, using the projection matrices provided by VRFrameData is the official and reliable way to compute the field of view (FOV) for each eye. The projection matrix encodes all the necessary perspective information, including FOV, aspect ratio, and near/far clip planes.

How It Works #

The standard perspective projection matrix used in VR includes values directly tied to the FOV. Here's the breakdown of the key calculations:

• Vertical FOV: Derived from the second row, second column element of the projection matrix (index 5 in the flat Float32Array).
• Horizontal FOV: Calculated using the vertical FOV and the aspect ratio, which can also be extracted from the projection matrix.
• Near/Far Clip Planes: Optional, but you can pull these from the matrix too if needed.

Step-by-Step Code Example #

Here's a practical JavaScript implementation to calculate FOV for both eyes using VRFrameData:

// Initialize a VRFrameData object to hold frame data
const frameData = new VRFrameData();

// Inside your rendering loop:
function render() {
  // Get the latest frame data from your VR display
  vrDisplay.getFrameData(frameData);

  // Calculate FOV for left and right eyes
  const leftEyeFOV = calculateFOV(frameData.leftProjectionMatrix);
  const rightEyeFOV = calculateFOV(frameData.rightProjectionMatrix);

  // Use the FOV values as needed (e.g., for debugging or custom rendering)
  console.log("Left Eye FOV:", leftEyeFOV);
  console.log("Right Eye FOV:", rightEyeFOV);

  // Continue the render loop
  requestAnimationFrame(render);
}

// Helper function to compute FOV from a projection matrix
function calculateFOV(projectionMatrix) {
  // Convert radians to degrees for readability
  const radToDeg = 180 / Math.PI;

  // Extract vertical FOV
  const tanHalfVerticalFOV = 1 / projectionMatrix[5];
  const verticalFOV = 2 * Math.atan(tanHalfVerticalFOV) * radToDeg;

  // Calculate aspect ratio from matrix elements
  const aspectRatio = projectionMatrix[5] / projectionMatrix[0];

  // Derive horizontal FOV using aspect ratio
  const tanHalfHorizontalFOV = aspectRatio * tanHalfVerticalFOV;
  const horizontalFOV = 2 * Math.atan(tanHalfHorizontalFOV) * radToDeg;

  // Optional: Extract near and far clip planes
  const zNear = projectionMatrix[14] / (projectionMatrix[12] + 1);
  const zFar = projectionMatrix[14] / (projectionMatrix[12] - 1);

  return {
    horizontal: parseFloat(horizontalFOV.toFixed(2)),
    vertical: parseFloat(verticalFOV.toFixed(2)),
    aspectRatio: parseFloat(aspectRatio.toFixed(2)),
    zNear: parseFloat(zNear.toFixed(2)),
    zFar: parseFloat(zFar.toFixed(2))
  };
}

Key Notes #

• Matrix Order: The projection matrix from VRFrameData is in column-major order, so the indices used in the code (like projectionMatrix[5]) correspond to the correct elements of the perspective matrix.
• Perspective vs Orthographic: This calculation assumes a perspective projection (standard for VR). If you're working with an orthographic projection (rare in VR), the FOV concept doesn't apply the same way.
• Accuracy: This method gives you the exact FOV used by the VR system for rendering, which is more reliable than the deprecated fieldOfView property since it accounts for any runtime adjustments the VR display might make.

内容的提问来源于stack exchange，提问作者brunnerh