Camera.h

/*
 * Copyright 2019 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/ui/types/Frustum.h>
#include <lagrange/ui/api.h>
 
namespace lagrange {
namespace ui {
 
 
class LA_UI_API Camera
{
public:
    enum class Type { PERSPECTIVE, ORTHOGRAPHIC };
 
    enum class RotationMode {
        TUMBLE, 
        TURNTABLE, 
        ARCBALL 
    };
 
    Camera(Type type = Type::PERSPECTIVE);
    virtual ~Camera() = default;
 
    static Camera default_camera(float width, float height, Type type = Type::PERSPECTIVE);
 
    void set_type(Type type);
    Type get_type() const { return m_type; }
 
    void set_position(const Eigen::Vector3f& pos);
    void set_lookat(const Eigen::Vector3f& dir);
    void set_position_up(const Eigen::Vector3f& pos, const Eigen::Vector3f& up);
    Eigen::Vector3f get_lookat() const { return m_lookat; }
    void set_up(const Eigen::Vector3f& up);
 
    Eigen::Vector3f get_position() const;
    Eigen::Vector3f get_direction() const;
    Eigen::Vector3f get_up() const;
 
    float get_far_plane() const;
    float get_near_plane() const;
 
    void set_window_dimensions(float width, float height);
    void set_aspect_ratio(float width, float height);
 
    void set_fov(float fov);
    float get_fov() const { return m_fov; }
 
    void set_planes(float znear, float zfar);
    float get_near() const { return m_znear; }
    float get_far() const { return m_zfar; }
 
    Eigen::Projective3f get_perspective() const;
 
    Eigen::Matrix4f get_view() const;
 
    Eigen::Matrix4f get_PV() const;
 
    Eigen::Matrix4f get_view_inverse() const { return m_Vinv; }
    Eigen::Projective3f get_perspective_inverse() const { return m_Pinv; }
 
    float get_window_width() const;
    float get_window_height() const;
    Eigen::Vector2f get_window_size() const;
 
 
    struct Ray
    {
        Eigen::Vector3f origin;
        Eigen::Vector3f dir;
    };
 
    Ray cast_ray(const Eigen::Vector2f& coord) const;
 
    Eigen::Vector2f project(const Eigen::Vector3f& pos) const;
 
    Eigen::Vector3f project_with_depth(const Eigen::Vector3f& pos) const;
 
    Eigen::Vector3f unproject(const Eigen::Vector2f& screen, float z = 0.0f) const;
 
    bool get_ray_to_screen(
        const Eigen::Vector3f& rayOrigin,
        const Eigen::Vector3f& rayDir,
        Eigen::Vector2f* beginOut,
        Eigen::Vector2f* endOut) const;
 
 
    void rotate_around_lookat(float angleRad);
    void rotate_tumble(float yaw_delta, float pitch_delta);
 
 
    void rotate_turntable(
        float yaw_delta,
        float pitch_delta,
        Eigen::Vector3f primary_axis = Eigen::Vector3f::Zero());
 
 
    void rotate_arcball(
        const Eigen::Vector3f& camera_pos_start,
        const Eigen::Vector3f& camera_up_start,
        const Eigen::Vector2f& mouse_start,
        const Eigen::Vector2f& mouse_current);
 
    void zoom(float delta);
    void dolly(float delta);
 
 
    int get_retina_scale() const { return m_retina_scale; }
 
    void set_retina_scale(int value) { m_retina_scale = value; }
 
    void move_forward(float delta);
    void move_right(float delta);
    void move_up(float delta);
 
    void set_ortho_viewport(Eigen::Vector4f viewport);
 
    Eigen::Vector4f get_ortho_viewport() const;
 
    void set_rotation_mode(RotationMode mode) { m_rotation_mode = mode; }
    RotationMode get_rotation_mode() const { return m_rotation_mode; }
 
    struct ViewportTransform
    {
        Eigen::Vector2f scale = Eigen::Vector2f::Ones();
        Eigen::Vector2f translate = Eigen::Vector2f::Zero();
 
        bool clip = false;
    };
 
    Camera transformed(const ViewportTransform& vt) const;
 
    Eigen::Vector2f inverse_viewport_transform(const ViewportTransform& vt, Eigen::Vector2f& pixel)
        const;
 
    bool is_pixel_in(const Eigen::Vector2f& p) const;
 
    bool intersects_region(const Eigen::Vector2f& begin, const Eigen::Vector2f& end) const;
 
    Eigen::Vector2f get_window_origin() const { return {m_window_origin_x, m_window_origin_y}; }
    void set_window_origin(float x, float y)
    {
        m_window_origin_x = x;
        m_window_origin_y = y;
    }
 
    enum class Dir { TOP, BOTTOM, LEFT, RIGHT, FRONT, BACK };
 
    bool is_orthogonal_direction(Dir dir) const;
 
    void set_orthogonal_direction(Dir dir);
 
    std::pair<Eigen::Vector3f, Eigen::Vector3f> get_orthogonal_direction(Dir dir) const;
 
    Frustum get_frustum() const;
 
    Frustum get_frustum(Eigen::Vector2f min, Eigen::Vector2f max) const;
 
protected:
    void update_view();
    virtual void update_perspective();
 
    void _changed();
 
    Eigen::Projective3f m_P;
    Eigen::Matrix4f m_V = Eigen::Matrix4f::Identity();
    Eigen::Projective3f m_Pinv;
    Eigen::Matrix4f m_Vinv = Eigen::Matrix4f::Identity();
 
    Eigen::Vector3f m_pos = Eigen::Vector3f(1, 0, 0);
    Eigen::Vector3f m_up = Eigen::Vector3f(0, 1, 0);
    Eigen::Vector3f m_lookat = Eigen::Vector3f::Zero();
 
    float m_aspectRatio = 1.0f;
    float m_fov = 3.14f / 4.0f; // in radians
    float m_znear = 0.0125f;
    float m_zfar = 128.0f;
 
    float m_windowWidth = 1.0f;
    float m_windowHeight = 1.0f;
    int m_retina_scale = 1;
    Type m_type = Type::PERSPECTIVE;
 
    float m_window_origin_x = 0.0f;
    float m_window_origin_y = 0.0f;
 
    Eigen::Vector4f m_ortho_viewport = Eigen::Vector4f(0.0f, 1.0f, 1.0f, 0.0f);
 
    RotationMode m_rotation_mode = RotationMode::TUMBLE;
};
} // namespace ui
} // namespace lagrange