matrix_camera.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_ALGORITHMS_CORE_MATRIX_CAMERA_H
#define VCL_ALGORITHMS_CORE_MATRIX_CAMERA_H
 
#include <vclib/space/core.h>
 
namespace vcl {
 
template<Point3Concept PointType>
void lookAtMatrix(
    auto*            res,
    const PointType& eye,
    const PointType& center,
    const PointType& up,
    Handedness       handedness = RIGHT_HAND)
{
    detail::lookAtMatrix(res, eye, center, up, handedness);
}
 
template<MatrixConcept Matrix44, Point3Concept PointType>
Matrix44 lookAtMatrix(
    const PointType& eye,
    const PointType& center,
    const PointType& up,
    Handedness       handedness = RIGHT_HAND)
{
    Matrix44 res(4, 4);
    lookAtMatrix(res.data(), eye, center, up, handedness);
    return res;
}
 
template<Point3Concept PointType>
void lookAtMatrixLeftHanded(
    auto*            res,
    const PointType& eye,
    const PointType& center,
    const PointType& up)
{
    lookAtMatrix(res, eye, center, up, LEFT_HAND);
}
 
template<MatrixConcept Matrix44, Point3Concept PointType>
Matrix44 lookAtMatrixLeftHanded(
    const PointType& eye,
    const PointType& center,
    const PointType& up)
{
    Matrix44 res(4, 4);
    lookAtMatrix(res.data(), eye, center, up, LEFT_HAND);
    return res;
}
 
template<typename Scalar>
void projectionMatrix(
    auto*      res,
    Scalar     fov,
    Scalar     aspect,
    Scalar     nearPlane,
    Scalar     farPlane,
    bool       homogeneousNDC,
    Handedness handedness = RIGHT_HAND)
{
    detail::projectionMatrix(
        res, fov, aspect, nearPlane, farPlane, homogeneousNDC, handedness);
}
 
template<MatrixConcept Matrix44, typename Scalar>
Matrix44 projectionMatrix(
    Scalar     fov,
    Scalar     aspect,
    Scalar     nearPlane,
    Scalar     farPlane,
    bool       homogeneousNDC,
    Handedness handedness = RIGHT_HAND)
{
    Matrix44 res(4, 4);
    projectionMatrix(
        res.data(),
        fov,
        aspect,
        nearPlane,
        farPlane,
        homogeneousNDC,
        handedness);
    return res;
}
 
template<typename Scalar>
void projectionMatrixLeftHanded(
    auto*  res,
    Scalar fov,
    Scalar aspect,
    Scalar nearPlane,
    Scalar farPlane,
    bool   homogeneousNDC)
{
    Scalar h = 1.0 / std::tan(vcl::toRad(fov) * 0.5);
    Scalar w = h * 1.0 / aspect;
    projectionMatrix(
        res, fov, aspect, nearPlane, farPlane, homogeneousNDC, LEFT_HAND);
}
 
template<MatrixConcept Matrix44, typename Scalar>
Matrix44 projectionMatrixLeftHanded(
    Scalar fov,
    Scalar aspect,
    Scalar nearPlane,
    Scalar farPlane,
    bool   homogeneousNDC)
{
    Matrix44 res(4, 4);
    projectionMatrix(
        res.data(),
        fov,
        aspect,
        nearPlane,
        farPlane,
        homogeneousNDC,
        LEFT_HAND);
    return res;
}
 
template<typename Scalar>
void orthoProjectionMatrix(
    auto*      res,
    Scalar     left,
    Scalar     right,
    Scalar     top,
    Scalar     bottom,
    Scalar     nearPlane,
    Scalar     farPlane,
    bool       homogeneousNDC,
    Handedness handedness = RIGHT_HAND)
{
    detail::orthoProjectionMatrix(
        res,
        left,
        right,
        top,
        bottom,
        nearPlane,
        farPlane,
        homogeneousNDC,
        handedness);
}
 
template<MatrixConcept Matrix44, typename Scalar>
Matrix44 orthoProjectionMatrix(
    Scalar     left,
    Scalar     right,
    Scalar     top,
    Scalar     bottom,
    Scalar     nearPlane,
    Scalar     farPlane,
    bool       homogeneousNDC,
    Handedness handedness = RIGHT_HAND)
{
    Matrix44 res(4, 4);
    orthoProjectionMatrix(
        res.data(),
        left,
        right,
        top,
        bottom,
        nearPlane,
        farPlane,
        homogeneousNDC,
        handedness);
    return res;
}
 
template<MatrixConcept Matrix44, Point3Concept PointType>
PointType unprojectScreenPosition(
    const PointType&                         screenPos,
    const Matrix44&                          modelViewProjection,
    const Point4<typename Matrix44::Scalar>& viewport,
    bool                                     homogeneousNDC)
{
    using Scalar       = Matrix44::Scalar;
    const Matrix44 inv = modelViewProjection.inverse();
    Point4<Scalar> p(
        (screenPos.x() - viewport[0]) / viewport[2] * 2.0 - 1.0,
        (screenPos.y() - viewport[1]) / viewport[3] * 2.0 - 1.0,
        homogeneousNDC ? 2.0 * screenPos.z() - 1.0 : screenPos.z(),
        1.0);
    p = inv * p;
    if (p.w() == 0.0) {
        throw std::runtime_error("unproject: division by zero");
    }
    return p.template head<3>() / p.w();
}
 
} // namespace vcl
 
#endif // VCL_ALGORITHMS_CORE_MATRIX_CAMERA_H