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/core/signal.h>
#include <easy3d/renderer/frame.h>
 
 
namespace easy3d {
 
 
    class Viewer;
    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;
 
        // Some useful transformations
        //     - camera position: -transpose(R) * t. Because when transforming from world to camera: P' = R * P + t.
        //     - view direction: transpose(R) * vec3(0, 0, -1), which is actually the negative Z axis of the frame.
        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; // my version
 
    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:
        // The camera will move around the pivot point if set.
        void setPivotPoint(const vec3 &point);
        vec3 pivotPoint() const;
 
    public:
        ManipulatedCameraFrame *frame() const { return frame_; }
    public:
        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