ViewportAutoZoomFocus.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/AutoZoomFocus.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/Angle.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    Class: AutoZoomFocus
 
    \brief Logic for automatically zooming a Camera or Viewport to a certain location or having certain objects in focus of the frame.
    *-----------------------------------------------------------------------------------------------**/
    struct AutoZoomFocus
    {
        AutoZoomFocus() {}
        AutoZoomFocus(const UUID& model)
            : targets({ model })
        {};
        AutoZoomFocus(const Buffer<UUID>& models)
            : targets(models)
        {};
        AutoZoomFocus(SnapLocation focus)
            : snap(focus)
        {};
        AutoZoomFocus(SnapLocation focus, const Buffer<UUID>& models)
            : targets(models)
            , snap(focus)
        {};
        AutoZoomFocus(SnapLocation focus, const UUID& model)
            : targets({ model })
            , snap(focus)
        {};
        void clear()
        {
            targets.clear();
            snap = SnapLocation::e_no_snap;
            bounds = Constant<Bounds<3, fltp08>>::NaN;
            angle_offsets = Vector<3, Angle<fltp08>>(Angle<fltp08>(0));
            transformed_offsets = Vector<3, fltp08>(0.0);
            worldspace_offsets = Vector<3, fltp08>(0.0);
            zoom_bounds_expansion = 0.0;
        }
        bool operator==(const AutoZoomFocus& layout) const
        {
            if (layout.targets != targets)
                return false;
            if (memcmp(&layout.bounds, &layout, sizeof(Bounds<3, fltp08>)) != 0)
                return false;
            if (layout.angle_offsets != angle_offsets)
                return false;
            if (layout.transformed_offsets != transformed_offsets)
                return false;
            if (layout.worldspace_offsets != worldspace_offsets)
                return false;
            if (layout.snap != snap)
                return false;
            if (layout.zoom_bounds_expansion != zoom_bounds_expansion)
                return false;
            if (layout.lag_time != lag_time)
                return false;
            if (layout.grip_tolerance != grip_tolerance)
                return false;
            if (layout.use_true_extents != use_true_extents)
                return false;
            return true;
        }
        bool operator!=(const AutoZoomFocus& layout) const
        {
            return !(layout == *this);
        }
        Buffer<UUID> targets;
        Bounds<3, fltp08> bounds = Constant<Bounds<3, fltp08>>::NaN;
        Vector<3, Angle<fltp08>> angle_offsets = Vector<3, Angle<fltp08>>(Angle<fltp08>(0));
        Vector<3, fltp08> transformed_offsets = Vector<3, fltp08>(0.0);
        Vector<3, fltp08> worldspace_offsets = Vector<3, fltp08>(0.0);
        SnapLocation snap = SnapLocation::e_no_snap;
        fltp08 zoom_bounds_expansion = 0.0;
        TimeSpan lag_time = TimeSpan(1.0);
        Angle<fltp08> grip_tolerance = Angle<fltp08>(DEGREES, 0.5);//can help prevent camera jitter
        fltp08 bounds_edge_tolerance_mult = 0.25;//can help prevent camera jitter
        fltp08 bounds_center_tolerance = 1.0;//can help prevent camera jitter
        bool use_true_extents = true;
        bool clear_animations = true;
        bool override_camera_lock_visible = true;
        bool override_camera_lock_invisible = false;
        bool override_default_snap = true;
    };
}