Calculation of far distance plane based on yaw and pitch for a map renderer

Question

I'm working on a vector map renderer. I want to calculate the far plane for a protective transformation, based on the yaw, pitch, roll and height of the camera above the map. Yaw (looking to the left and right), pitch (the direction you also have on Google Maps e.g.) and roll (rotation around Y axis in this case) are limited to 30°.

I recorded a video here of the movements users are able to do: https://youtu.be/NejhvULvhys

As you can see there is some clipping, which demonstrates that the calculation of the far distance field is not correct yet. Though, please note that I do have a working version if you only use pitch and roll. So this question is about: How do I calculate the far distance plane if I not only want pitch and roll?

I prepared a geogebra drawing to explain the current calculations. It is not that simple because there are not that many right-angles: https://www.geogebra.org/m/cvhtwhng

In that diagram:

• height of the blue triangle is the height of the camera.
• Roll is not really relevant as it does not influence the far distance plane.
• Yaw and pitch are equal to "pitch" in the diagram. Note that this is only a 2d cut of the real situation which is 3d. So the geogebra diagram is a simplification.

Finally, I have some code to share.

• The implementation of the geogebra paramter d: https://github.com/maplibre/maplibre-rs/blob/31c3fa7ebc5dd47a9f298e787b858e2059aa4c5d/maplibre/src/render/view_state.rs#L86-L93​
• Alternative implementation for the same above (adds yaw and pitch together and uses that as “pitch” from geogebra: https://github.com/maplibre/maplibre-rs/blob/31c3fa7ebc5dd47a9f298e787b858e2059aa4c5d/maplibre/src/render/view_state.rs#L144-L149​)​
• Calculation of the camera height, above ground: https://github.com/maplibre/maplibre-rs/blob/31c3fa7ebc5dd47a9f298e787b858e2059aa4c5d/maplibre/src/render/view_state.rs#L194-L203​
• This function experiments with adding together different additional heights calculated from the “geogebra function": https://github.com/maplibre/maplibre-rs/blob/31c3fa7ebc5dd47a9f298e787b858e2059aa4c5d/maplibre/src/render/view_state.rs#L205-L265​
• The final view projection matrix is built here: https://github.com/maplibre/maplibre-rs/blob/31c3fa7ebc5dd47a9f298e787b858e2059aa4c5d/maplibre/src/render/view_state.rs#L270-L326​

I have tried a few method to calculate the far distance plane based on the current pitch and yaw. Unfortunately, I have not gained confidence whether the correct is calculated. I am certain that the geogebra calculations are correct as they work well for the "only pitch" case. Though, the combination of both seems more involved.

Let me know if something is unclear!

Answer 1

One tactic we can use here is to fire a ray through each corner of the screen and take the farthest intersection with the map plane.

Based on your camera's field of view and aspect ratio, you can compute 4 vectors in camera space that point to the corners of the screen, with a z component of 1:

ray.y = ± tan(fov / 2.0)
ray.x = ± aspect * ray.y
ray.z = 1 (or -1 if that's "forward" for your coordinate system)

These only need to change when your window size or camera FoV change, not on every rotation.

When the camera rotates, you can transform these rays into world space using the camera transform matrix. (Or construct them directly by adding together camera.forward + tan(fov/2.0) * (±camera.up ± aspect * camera.right) )

Now you can use a ray vs plane intersection function to get the time t a particle starting at the camera and moving with this ray as its velocity would hit the map plane. The greatest of these 4 t values is your far plane depth (and the least is your near plane, if your map is 2D with no elevation / raised overlays).

This isn't an expensive physics raycast, just a very simple subtraction, dot product, and division:

float GetIntersectionTime(Vector3 rayOrigin, Vector3 rayDirecton, Vector3 planeOrigin, Vector3 planeNormal) {
    float distance = Vector3.Dot(planeOrigin - rayOrigin, planeNormal);

    float approachSpeed = Vector3.Dot(rayDirection, planeNormal);

    // Returns an infinity if the ray is
    // parallel to the plane and never intersects,
    // or NaN if the ray is in the plane
    // and intersects everywhere.
    return distance / approachSpeed;

    // Otherwise returns t such that
    // rayOrigin + t * rayDirection
    // is in the plane, to within rounding error.
}

Note that the distance term can be pre-calculated as it only changes when the camera translates, and is constant for all rays and all rotations from a given camera position. If your plane is axis-aligned, then the dot product is just taking the e.g. z component, simplifying even further.