Camera.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: Camera
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/SelectionInfo.h>
#include <NDEVR/SnapLocation.h>
#include <NDEVR/CameraBackground.h>
#include <NDEVR/AutoZoomFocus.h>
#include <NDEVR/CameraAnimation.h>
#include <NDEVR/Resource.h>
#include <NDEVR/Time.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/Vector.h>
#include <NDEVR/Angle.h>
#include <NDEVR/Set.h>
#include <NDEVR/BasicResourceListener.h>
#include <functional>
#if NDEVR_VIEWPORT
namespace NDEVR
{
    class ViewportFormat;
    struct ScreenshotRequest
    {
    public:
        ScreenshotRequest() {};
        ScreenshotRequest(std::function<void(const StringView& image_id)> callback)
            : callback(callback)
        {}

        bool operator==(const ScreenshotRequest&) const
        {
            return false;
        }

        bool operator!=(const ScreenshotRequest&) const
        {
            return true;
        }
        std::function<void(const StringView& image_id)> callback; 
    };

    class NDEVR_DESIGN_API Camera : public Model
    {
    public:
        Resource<Vertex<3, fltp08>> offset; 
        Resource<Vector<3, Angle<fltp08>>> orientation; 
        Resource<Vertex<3, fltp08>> target; 
        Resource<Vertex<2, fltp08>> cross_hairs; 
        Resource<fltp08> near_plane; 
        Resource<fltp08> far_plane; 
        Resource<fltp08> zoom_extent_mult; 
        Resource<fltp08> default_zoom_delta; 
        Resource<String> camera_source; 
        Resource<String> camera_format; 
        Resource<ScreenshotRequest> screenshot_request; 
        Resource<Vector<2, Angle<fltp08>>> perspective_fov; 
        Resource<fltp08> orthographic_fov; 
 
        Resource<Time> last_visible_update_time; 
        Resource<bool> location_lock; 
        Resource<bool> rotation_lock; 
        Resource<bool> is_orthographic; 
        Resource<bool> is_exposed; 
        Resource<bool> is_valid; 
        Resource<fltp08> plane_intercept_value; 
        Resource<fltp08> orthographic_perspective_ratio; 
        Resource<SelectionInfo> selection_info; 
        Resource<fltp04> pixel_thickness; 
 
        DynamicPointer<Set<UUID>> visible_items; 
        DynamicPointer<Set<UUID>> hidden_items; 
    public:
        Camera(const Model& camera);
        Camera(const Camera& camera);
        ~Camera();
        bool refreshMovement(const Time& current_time, const DesignObjectLookup* lookup = nullptr, const TimeSpan& time_out = TimeSpan(0.2));
        void refreshFocusBounds(const DesignObjectLookup* lookup, TimeSpan animation_time);
        void clearAnimations();
        void move(const Ray<3, fltp08>& distance);
        void move(const Ray<3, fltp08>& distance, const CameraAnimation& original);
        void zoom(fltp08 distance_mult, const CameraAnimation& original);
        void moveForward(fltp08 distance);
        void moveHorizontal(fltp08 distance);
        void moveVertical(fltp08 distance);
        void move(fltp08 horizontal_distance, fltp08 vertical_distance);
        void move(fltp08 horizontal_distance, fltp08 vertical_distance, const CameraAnimation& original);
        void lookHorizontal(fltp08 percent);
        void lookVertical(fltp08 percent);
        void look(fltp08 horz_percent, fltp08 vert_percent);
        void look(fltp08 horz_percent, fltp08 vert_percent, const CameraAnimation& original);
        void addObjectToVisible(const Model& model);
        void addObjectsToVisible(const Buffer<UUID>& models, DesignObjectLookup* lookup);
        void moveHorizontalPercent(fltp08 percent);
        void moveVerticalPercent(fltp08 percent);
        void movePercent(fltp08 horizontal_percent, fltp08 vertical_percent);
        void movePercent(fltp08 horizontal_percent, fltp08 vertical_percent, const CameraAnimation& original);
        void panPercent(fltp08 horizontal_percent, fltp08 vertical_percent, const CameraAnimation& original);
        void addAnimation(CameraAnimation animation, bool clear_current_animations = true);
        void addZoomAnimation(fltp08 distance_mult, const TimeSpan& time, bool clear_animations = true);
        void addLookatAnimation(Vector<3, fltp08> lookat, const TimeSpan& time, bool clear_animations = true);
        void addIsOrthographicAnimation(bool is_orthographic, const TimeSpan& time, bool clear_animations = true);
        void addOrbitAnimation(Vector<3, fltp08> target, Vector<3, Angle<fltp08>> orient, fltp08 zoom, bool face_target, const TimeSpan& time, bool clear_animations = true);
        void setAutoZoomFocus(AutoZoomFocus focus);
        void addZoomToExtentsAnimation(SnapLocation location, Bounds<3, fltp08> object, const TimeSpan& time, bool use_true_extents = true, bool clear_animations = true, Vector<3, Angle<fltp08>> angle_offsets = Vector<3, Angle<fltp08>>(Angle<fltp08>(0)));
        void addZoomToExtentsAnimation(Bounds<3, fltp08> object, const TimeSpan& time, bool use_true_extents = true, bool clear_animations = true, Vector<3, Angle<fltp08>> angle_offsets = Vector<3, Angle<fltp08>>(Angle<fltp08>(0)));
        void addZoomToExtentsAnimation(Vector<3, Angle<fltp08>> orientation, Bounds<3, fltp08> object, const TimeSpan& time, bool use_true_extents = true, bool clear_animations = true);
        void addZoomMultiplierAnimation(fltp08 multiplier, const TimeSpan& time, bool clear_animations = true);
        void postUpdateBackground();
        void clearAutozoomFocus();
        void copyFrom(const Camera& object);
        void updateGridSpacing();
        [[nodiscard]] bool hasFullAutoFocus() const;
        void readMetaData();
        void writeMetaData();
        fltp04 pixelThickness() const;
        [[nodiscard]] const Ray<3, fltp08>& getLookat() const;
        [[nodiscard]] SnapLocation currentSnapLocation() const;
        [[nodiscard]] SnapLocation preferredSnapLocation() const;
        [[nodiscard]] bool hasWorldGridAlignment() const;

        [[nodiscard]] bool isUserCamera() const;
        void setupFromFormat(const ViewportFormat& format);
        [[nodiscard]] ViewportFormat format() const;
        [[nodiscard]] bool isObjectPotentiallyVisibleToCamera(const UUID& id) const;

        [[nodiscard]] Vertex<2, fltp08> toScreenSpace(const Vector<2, fltp04>& pixel_location) const;
        [[nodiscard]] Vertex<3, fltp08> computedOffset() const { return m_computed_offset; };
        [[nodiscard]] Vertex<3, fltp08> toWorldSpaceFromPixelSpace(const Vector<2, fltp04>& pixel_location, fltp08 depth_percent) const;
        [[nodiscard]] Vertex<3, fltp08> toWorldSpaceFromViewSpace(const Vector<2, fltp08>& view_location, fltp08 depth_percent) const;
        [[nodiscard]] SelectionInfo createSelectionInfo() const;
        void updateSelectionInfo(const Vector<2, fltp04>& pixel_location, SelectionInfo& info) const;
        void updateSelectionInfo(const Bounds<2, fltp04>& pixel_location, SelectionInfo& info) const;
        void updateSelectionInfo(const Polygon<fltp04>& pixel_location, SelectionInfo& info) const;
        [[nodiscard]] Vector<3, Angle<fltp08>> gotoOrientation() const;
        [[nodiscard]] Vector<2, Angle<fltp08>> activeFOV() const;
        [[nodiscard]] Vector<2, fltp08> activeOrthoSize() const;
        [[nodiscard]] Vector<3, fltp08> gotoLocation() const;
        [[nodiscard]] Bounds<3, fltp08> getOrthographicBounds() const;
        [[nodiscard]] Bounds<2, Angle<fltp08>> getPerspectiveBounds() const;
        [[nodiscard]] Vector<2, uint04> windowSize() const;
        void setNearPlaneBounds(const Bounds<1, fltp08>& near_plane_bounds) { m_near_plane_bounds = near_plane_bounds; }
        void setFarPlaneBounds(const Bounds<1, fltp08>& near_plane_bounds) { m_far_plane_bounds = near_plane_bounds; }
        [[nodiscard]] const Bounds<1, fltp08>& nearPlaneBounds() const { return m_near_plane_bounds; }
        [[nodiscard]] const Bounds<1, fltp08>& farPlaneBounds() const { return m_far_plane_bounds; }

        void setProjectionTransform(const Matrix<fltp08>& transform);
        [[nodiscard]] Matrix<fltp08> viewToWorldSpace() const;
        [[nodiscard]] Matrix<fltp08> worldToViewSpace() const;
        [[nodiscard]] Matrix<fltp08> viewMatrix() const;
        [[nodiscard]] Matrix<fltp08> projectionMatrix() const;
        [[nodiscard]] Matrix<fltp08> calculateProjectionMatrix() const;
        void setWindowSize(const Vector<2, uint04>& size);
        void setUseReferenceSize(bool use_reference_size);
        [[nodiscard]] fltp08 calculatedReferenceSize() const;
        void setReferenceSize(fltp08 size);
        [[nodiscard]] Vector<2, Angle<fltp08>> getRotateAroundPoint(const Vector<3, fltp04>& vCenter) const;
        [[nodiscard]] Bounds<3, fltp08> getFocusBounds() const { return m_autozoom_focus.bounds; }
        void setFocusBounds(const Bounds<3, fltp08>& bounds) { m_autozoom_focus.bounds = bounds; }
        //Vector<3, fltp08> lastReference() const { return m_last_refrence; }
        [[nodiscard]] const CameraBackground& cameraBackground() const { return m_camera_background; }
        [[nodiscard]] CameraBackground& cameraBackground() { return m_camera_background; }
        static constexpr StringView TypeName() { return "camera"; }
        fltp08 widthToHeightRatio() const;
        fltp08 heightToWidthRatio() const;
    private:
        void _zoomToTargetModel(const Model& model, const DesignObjectLookup* lookup);
        void _setupListeners();
        void executeAnimations(Time current_time);
        [[nodiscard]] Bounds<3, fltp08> boundsOfTargets(const DesignObjectLookup* lookup) const;
    private:
 
        Ray<2, uint04> m_window_size; 
        fltp08 m_reference_size; 
 
        Bounds<1, fltp08> m_near_plane_bounds; 
        Bounds<1, fltp08> m_far_plane_bounds; 
 
        Ray<3, fltp08> m_lookat; 
        Ray<3, fltp08> m_up_direction; 
        Vertex<3, fltp08> m_computed_offset = Constant<Vertex<3, fltp08>>::Invalid; 
        Vertex<3, fltp08> m_goto_initial_offset; 
        Vertex<3, fltp08> m_goto_initial_target; 
        Vector<3, Angle<fltp08>>  m_goto_initial_orientation; 
        fltp08 m_goto_initial_ortho_bounds; 
        fltp08 m_goto_initial_zoom_extent_mult; 
        AutoZoomFocus m_autozoom_focus; 
        CameraBackground m_camera_background; 
        Matrix<fltp08> m_custom_transform; 
        Buffer<CameraAnimation> m_animations; 
        BasicResourceListener m_units_listener; 
        SnapLocation m_default_snap = SnapLocation::e_no_snap; 
        bool m_use_reference_size = true; 
        bool m_refresh_background = false; 
    };
};//End namespace NDEVR
#endif