camera.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D 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
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/

 
#ifndef EASY3D_RENDERER_CAMERA_H
#define EASY3D_RENDERER_CAMERA_H
 
 
#include <easy3d/core/types.h>
#include "easy3d/util/signal.h"
 
 
namespace easy3d {
 
 
    class Frame;
    class ManipulatedCameraFrame;
    class KeyFrameInterpolator;

    class Camera {
    public:
        Camera();
        virtual ~Camera();

        Camera(const Camera &camera);
        
        Camera &operator=(const Camera &camera);

        enum Type {
            PERSPECTIVE,    
            ORTHOGRAPHIC    
        };

    public:
        vec3 position() const;
        vec3 upVector() const;
        vec3 viewDirection() const;
        vec3 rightVector() const;
        quat orientation() const;
 
        // -----------------------------------------------------------------

        void set_from_model_view_matrix(const mat4 &mv) const;
        void set_from_calibration(float fx, float fy, float skew, float cx, float cy,
                                  const mat3 &R, const vec3 &t, bool convert = true);
        
        void set_from_calibration(const mat34 &proj);
 
        // -----------------------------------------------------------------

        void set_projection_matrix(const mat4 &proj);

        void set_modelview_matrix(const mat4 &mv);
 
        // -----------------------------------------------------------------
 
    public:
        void setPosition(const vec3 &pos) const;
        void setOrientation(const quat &q) const;
        void setOrientation(float theta, float phi) const;
        void setUpVector(const vec3 &up, bool noMove = true) const;
        void setViewDirection(const vec3 &direction) const;

    public:
        void lookAt(const vec3 &target) const;
        void showEntireScene() const;
        void fitSphere(const vec3 &center, float radius) const;
        void fitBoundingBox(const vec3 &min, const vec3 &max) const;
        void fitScreenRegion(int xmin, int ymin, int xmax, int ymax) const;
        
        void centerScene() const;
 
    public:
        KeyFrameInterpolator *keyframe_interpolator() const { return interpolationKfi_; }

        void interpolateToLookAt(const vec3 &point);

        void interpolateToFitScene();

        void interpolateTo(const Frame* frame, float duration);
 
    public:
        Type type() const { return type_; }

        float fieldOfView() const { return fieldOfView_; }

        float horizontalFieldOfView() const {
            return 2.0f * std::atan(std::tan(fieldOfView() / 2.0f) * aspectRatio());
        }

        float aspectRatio() const {
            return static_cast<float>(screenWidth_) / static_cast<float>(screenHeight_);
        }

        int screenWidth() const { return screenWidth_; }

        int screenHeight() const { return screenHeight_; }

        float pixelGLRatio(const vec3 &position) const;

        float zNearCoefficient() const { return zNearCoef_; }

        float zClippingCoefficient() const { return zClippingCoef_; }

        virtual float zNear() const;
        virtual float zFar() const;
        virtual void getOrthoWidthHeight(float &halfWidth, float &halfHeight) const;
        void getFrustumPlanesCoefficients(float coef[6][4]) const;

        void getFrustumPlanesCoefficients2(float coef[6][4]) const;
 
    public:
        void setType(Type type);
        void setFieldOfView(float fov);

        void setHorizontalFieldOfView(float hfov) {
            setFieldOfView(2.0f * std::atan(std::tan(hfov / 2.0f) / aspectRatio()));
        }

        void setFOVToFitScene();

        void setAspectRatio(float aspect) {
            setScreenWidthAndHeight(int(100.0f * aspect), 100);
        }

        void setScreenWidthAndHeight(int width, int height);

        void setZNearCoefficient(float coef) {
            zNearCoef_ = coef;
            projectionMatrixIsUpToDate_ = false;
        }

        void setZClippingCoefficient(float coef) {
            zClippingCoef_ = coef;
            projectionMatrixIsUpToDate_ = false;
        }


    public:
        float sceneRadius() const { return sceneRadius_; }

        vec3 sceneCenter() const { return sceneCenter_; }
        float distanceToSceneCenter() const;
 
    public:
        void setSceneRadius(float radius);
        void setSceneCenter(const vec3 &center);

        void setSceneBoundingBox(const vec3 &min, const vec3 &max);
 
    public:
        void setPivotPoint(const vec3 &point);
        vec3 pivotPoint() const;
 
    public:
        ManipulatedCameraFrame *frame() const { return frame_; }
        void setFrame(ManipulatedCameraFrame *const mcf);
 
    public:
        void computeProjectionMatrix();
        void computeModelViewMatrix();
        const mat4 &projectionMatrix() const;
        const mat4 &modelViewMatrix() const;
        mat4 modelViewProjectionMatrix() const;

    public:
        vec3 cameraCoordinatesOf(const vec3 &src) const;
        vec3 worldCoordinatesOf(const vec3 &src) const;

    public:
        vec3 projectedCoordinatesOf(const vec3 &src, const Frame *frame = nullptr) const;
        vec3 unprojectedCoordinatesOf(const vec3 &src, const Frame *frame = nullptr) const;

        void convertClickToLine(int x, int y, vec3 &orig, vec3 &dir) const;
 
    private:
        void modified();
 
    private:
        // Frame
        ManipulatedCameraFrame *frame_;
 
        // Camera parameters
        int screenWidth_, screenHeight_; // size of the window, in pixels
        float fieldOfView_;              // in radians
        vec3 sceneCenter_;
        float sceneRadius_; // OpenGL units
        float zNearCoef_;
        float zClippingCoef_;
        float orthoCoef_;
        Type type_;                 // PERSPECTIVE or ORTHOGRAPHIC
        mat4 modelViewMatrix_;        // Buffered model view matrix.
        bool modelViewMatrixIsUpToDate_;
        mat4 projectionMatrix_;        // Buffered projection matrix.
        bool projectionMatrixIsUpToDate_;
 
        // Key frame interpolation
        KeyFrameInterpolator *interpolationKfi_;
 
    public:
        Signal<> frame_modified;
    };
 
}
 
#endif // EASY3D_RENDERER_CAMERA_H