给定 4 个世界点，我如何计算相机 position？

Question

So I have 4 world points as Vector3 objects.

I also have a camera with a fixed rotation.

I'd like to keep my camera's rotation, and keep it centered on 0,0,0 and can guarantee that my points will allow this as they're generated around the origin as well. I just need to move the camera back until they're all in view.

I'm new to Unity and thinking in 3D generally, so I'm not really sure what I'm looking for here, but I feel like this should be easy enough?

I think I could move the camera back until I get a WorldToViewportPoint that's between 0 - 1 but I'd like to apply an existing smooth move function I have which takes a start and end point, so I'd like a way to calculate this before moving the camera.

Any pointers would be appreciated.
Thanks

Answer 1

Can't test this at the moment but using trigonometry and some camera functions, you can find the distance from the origin along camera's forward you need to be to view each point, then take the minimum. Then, go that distance along camera's forward.

The advantage of this method is that the only requirement is that the camera be looking directly at (or away from) the origin. The camera can have any rotation.

Further details are in comments:

using System.Linq; // convenience

float GetClosestCameraDist(Camera cam, Vector3 point)
{ 
    // cam vertical/horizontal fov in radians
    float vFov = cam.fieldOfView * Mathf.Deg2Rad;
    float hFov = Camera.VerticalToHorizontalFieldOfView(cam.fieldOfView,
            cam.aspect) * Mathf.Deg2Rad;

    // how far point is from origin along camera's axes
    float Yp = Vector3.Dot(point, cam.transform.up);
    float Xp = Vector3.Dot(point, cam.transform.right);
    float Zp = Vector3.Dot(point, cam.transform.forward);

    // how far point should be from cam along cam forward to ensure 
    // point is within fov along camera axes
    float d = Mathf.Max(
            Mathf.Abs(Yp) / Mathf.Tan(vFov/2f),
            Mathf.Abs(Xp) / Mathf.Tan(hFov/2f) );

    // return how far cam should be from origin along cam forward
    // should be negative if it goes cam->  ... origin 
    //           positive if it goes origin ... cam->
    return Zp - d; 
}

Vector3 GetClosestCameraPos(Camera cam, List<Vector3> points)
{
    // calculate lowest needed distance from origin to cam along cam forward
    // lowest because the larger this is, the more forward camera is
    float c = points.Select(p => GetClosestCameraDist(cam, p)).Min();

    // go that distance along cam forward to find closest-to-points position.
    return c * cam.transform.forward;
}

Surely not the most efficient algorithm but with only 4 points it shouldn't be horrible. It could be faster by only doing the 2 points that are most distant from the origin along the camera's up/right axes.

---

And... I think this change to the outer function should work for any relative positioning of camera/origin (!) :

Vector3 GetClosestCameraPosOffset(Camera cam, List<Vector3> points)
{
    // Project origin onto camera forward
    Vector3 originOffset = cam.transform.position + cam.transform.forward 
            * Vector3.Dot(cam.transform.forward, 
                -cam.transform.position
            ).normalized;

    // calculate lowest needed distance from origin to cam along cam forward
    // lowest because the larger this is, the more forward camera is.
    // Only first... pretend the camera and point are shifted so the camera is 
    // pointing at/away from origin for easier calculation.
    float c = points.Select(p => GetClosestCameraDist(cam, p - originOffset)).Min();

    // go that distance along cam forward to find closest-to-points position.
    // Add the offset back in to stop pretending
    return c * cam.transform.forward + originOffset;
}