SnapController.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: SnapController
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/SnapPoint.h>
#include <NDEVR/MouseController.h>
#if NDEVR_VIEWPORT
#include <NDEVR/KeyController.h>
#include <NDEVR/SelectionArea.h>
#include <NDEVR/Plane.h>
#include <NDEVR/TextConstructor.h>
#include <functional>
namespace NDEVR
{
 
    class DesignObjectLookup;

    class NDEVR_DESIGN_API SnapController : public MouseControllerBase, public KeyControllerBase
    {
    public:
        struct EditDimensionLockInformation
        {
            Vector<3, String> all_text; 
            String& text()
            {
                return all_text[dimension];
            }
            uint01 dimension = Constant<uint01>::Invalid;       
            uint04 cursor_position = Constant<uint04>::Invalid; 
        };

        enum PointsDrawMode
        {
              e_points      
            , e_triangle    
            , e_lines       
            , e_line_fan    
            , e_polyline    
        };

        enum LockMode
        {
              e_lock_ignore_snap    
            , e_lock_to_nearest_snap
            , e_lock_if_no_snap     
            , e_only_allow_snap     
            , e_ignore              
        };
    public:
        explicit SnapController(DesignObjectLookup* manager);
        virtual ~SnapController(){}
        virtual void cancel();

        virtual bool processMouseEvent(MouseControllerEvent& event, SelectionInfo& info) override;
        virtual bool processKeyEvent(const KeyEvent& event, DesignObjectLookup* lookup, Camera* camera) override;

        void clearSnapSelection();
        uint04 pointCount() const { return m_points.size(); }
        virtual void setUpdateCallback(const std::function<void()>& callback) { m_update_callback = callback; }
        virtual void setFinishedCallback(const std::function<void(bool is_accepted)>& callback) { m_finished_callback = callback; }
        void lockAxis(uint01 axis, fltp08 lock) { m_lock_axis[axis] = lock; }
        SelectionMode selectionMode() const { return m_selection_mode; }
        void setSelectionMode(SelectionMode mode) { m_selection_mode = mode; }
        Vertex<3, fltp08> currentLocation() const { return m_location; }
        void setLockMode(LockMode mode);
        void setLockLine(const LineSegment<3, fltp08>& line);
        void setLockPlane(const Plane<3, fltp08>& plane);
        void setCustomSnapManager(const ConstPointer<SnapsManager>& snap_manager) { m_custom_snap_manager = snap_manager; };
        void setLocation(const Vertex<3, fltp08>& location, bool is_click = false, Camera* camera = nullptr);
        void setShowLengthLabels(bool show);
        void setShowPointLabels(bool show);
        void setPointsDrawMode(PointsDrawMode mode) { m_point_draw_mode = mode; }
        const Buffer<Vertex<3, fltp08>>& points() const { return m_points; }
        Vertex<3, fltp08> lastPoint() const { return m_location; }
        const Buffer<SnapPoint>& lastSnapPoints() const { return m_last_snap_points; }
 
        Resource<SnapPoint> current_snap_point; 
    protected:
        void processUserInput();
        virtual void addPoint(const Vertex<3, fltp08>& point);
        virtual void addPoint(const SnapPoint& point);
        virtual void begin();
        virtual void finish();
        virtual void updateLocation(const Vertex<3, fltp08>& location, bool is_click, Camera* camera);
        void addGuidePlaneModel();
        void addGuideLineModel();
        void addGuidePointModel();
        bool processMouseSnap(MouseControllerEvent& event, SelectionInfo& info);
        bool processMouseSelection(MouseControllerEvent& event);
        void setGuidePoint(uint04 index, const Vertex<3, fltp08>& p1, const UUID& material);
        void setGuidePlane(uint04 index, const Vector<3, fltp08>& normal, const Vertex<3, fltp08>& location, fltp08 radius);
        void setGuideLine(uint04 index, const Vertex<3, fltp08>& p1, const Vector<3, fltp08>& p2, const UUID& material);
        void calcLockLineLocation(SnapPoint& point, const SelectionInfo& info);
        void calcLockPlaneLocation(SnapPoint& point, const SelectionInfo& info);
        void setGuidePlaneVisible(bool visible);
        void setGuidePlaneVisible(uint04 index, bool visible);
        void setGuideLineVisible(bool visible);
        void setGuideLineVisible(uint04 index, bool visible);
        void setGuidePointVisible(bool visible);
        void setGuidePointVisible(uint04 index, bool visible);
        void drawDefaultGuideLines(const SnapPoint& point);
        void drawDefaultGuidePlane(const SnapPoint& point);
        Model setupGuideModel();
        void updateRecentGeometry(const SnapPoint& point);
        virtual void setupSelectionInfo(const MouseEvent& event, Camera* camera, SelectionInfo& info);
        SnapPoint calcSnapPoint(const SelectionInfo& info, DesignObjectLookup* lookup);
        UUID pointMaterial(const SnapPoint& point);
        UUID lineMaterial(const SnapPoint& point);
    protected:
        MouseEvent m_last_mouse_event;                          
        DesignObjectLookup* m_last_lookup = nullptr;            
        Camera* m_last_camera = nullptr;                        
        EditDimensionLockInformation m_user_edit;               
        Buffer<Vertex<3, fltp08>> m_points;                     
        Vertex<3, fltp08> m_lock_location;                      
        Vertex<3, fltp08> m_location;                           
        Vertex<3, fltp08> m_lock_axis;                          
        LineSegment<3, fltp08> m_lock_line;                     
        Plane<3, fltp08> m_lock_plane;                          
 
        SnapPoint m_original_snap;                              
        UUID m_current_line_material = Constant<UUID>::Invalid; 
 
        UUID m_free_point_material = Constant<UUID>::Invalid;       
        UUID m_point_material = Constant<UUID>::Invalid;            
        UUID m_edge_point_material = Constant<UUID>::Invalid;       
        UUID m_end_point_material = Constant<UUID>::Invalid;        
        UUID m_mid_point_material = Constant<UUID>::Invalid;        
        UUID m_center_point_material = Constant<UUID>::Invalid;     
        UUID m_on_face_point_material = Constant<UUID>::Invalid;    
 
        UUID m_free_line_material = Constant<UUID>::Invalid;            
        UUID m_locked_line_material = Constant<UUID>::Invalid;      
        UUID m_extend_line_material = Constant<UUID>::Invalid;      
        UUID m_perpendicular_line_material = Constant<UUID>::Invalid;
        UUID m_tangent_line_material = Constant<UUID>::Invalid;     
        UUID m_red_line_material = Constant<UUID>::Invalid;         
        UUID m_green_line_material = Constant<UUID>::Invalid;       
        UUID m_blue_line_material = Constant<UUID>::Invalid;        
 
        UUID m_last_selection_camera= Constant<UUID>::Invalid;      
 
        UUID m_guide_model = Constant<UUID>::Invalid;   
        UUID m_plane_mesh = Constant<UUID>::Invalid;    
        UUID m_line_mesh = Constant<UUID>::Invalid;     
        UUID m_point_mesh = Constant<UUID>::Invalid;    
        Buffer<UUID> m_guide_plane_model;               
        Buffer<UUID> m_guide_line_model;                
        Buffer<UUID> m_guide_point_model;               
 
        Buffer<UUID> m_line_guide_text;                 
        Buffer<UUID> m_point_guide_text;                
 
        Buffer<UUID> m_guide_plane_material;            
        Buffer<UUID> m_guide_line_material;             
        Buffer<UUID> m_guide_point_material;            
 
        Buffer<std::pair<UUID, uint04>> m_last_lines;   
        Buffer<std::pair<UUID, uint04>> m_last_meshes;  
        Buffer<std::pair<UUID, uint04>> m_last_points;  
        ConstPointer<SnapsManager> m_custom_snap_manager;   
        PointsDrawMode m_point_draw_mode;               
        std::function<void()> m_update_callback;        
        std::function<void(bool is_accepted)> m_finished_callback;  
        DesignObjectLookup* m_manager;                  
        SelectionMode m_selection_mode;                 
        Buffer<SnapPoint> m_last_snap_points;           
        LockMode m_lock_mode;                           
        bool m_is_active;                               
        bool m_show_length_label;                       
        bool m_show_location_label;                     
        bool m_is_vertical_locked = false;              
        bool m_is_horizontal_locked = false;            
        bool m_is_using_lock_plane = false;             
    };
}
 
#endif