MouseController.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: MouseController
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Camera.h>
#if NDEVR_VIEWPORT
#include <NDEVR/SoftwareService.h>
#include <NDEVR/Resource.h>
#include <NDEVR/Event.h>
#include <NDEVR/INIInterface.h>
namespace NDEVR
{
    class SelectionInfo;
    struct MouseControllerEvent
    {
        MouseControllerEvent(const MouseEvent& event)
            : mouse_event(event)
        {
        }
        const MouseEvent mouse_event;       
        DesignObjectLookup* lookup = nullptr;   
        Camera* camera = nullptr;       
        String cursor;              
    };

    class NDEVR_DESIGN_API MouseControllerBase : public SoftwareService
    {
    public:
        virtual bool processMouseEvent(MouseControllerEvent& event, SelectionInfo& info) = 0;
    };
    class SnapController;
 
    class DesignObjectLookup;

    class MouseController final : public INIInterface, public MouseControllerBase, public SoftwareServiceManager
    {
    public:
        enum ReferencePoint : uint01
        {
              e_map_center      
            , e_mouse_center    
            , e_screen_center   
        };

        enum MouseAction : uint01
        {
              e_ignore      
            , e_select      
            , e_inv_select      
            , e_orbit       
            , e_pan         
            , e_look_around     
            , e_zoom        
            , e_inv_zoom        
            , e_context_menu    
 
            , e_command     
        };

        enum MouseSelectionMode
        {
              e_select_model    
            , e_select_model_base   
            , e_select_material 
            , e_select_geometry 
            , e_select_bone     
        };

        class MouseActions
        {
        public:
            Resource<MouseAction> drag_action;          
            Resource<MouseAction> click_action;         
            Resource<MouseAction> double_click_action;      
            Resource<MouseSelectionMode> selection_mode;        
            Resource<ReferencePoint> preferred_reference;       
            Resource<fltp04> sensitivity;               
            Resource<Vector<2, bool>> inverted;         
 
            Resource<ReferencePoint> double_click_reference;    
        public:
            MouseActions();
            MouseActions(const MouseActions& actions);
        };
    public:
        NDEVR_DESIGN_API MouseController();
        NDEVR_DESIGN_API virtual ~MouseController();
        MouseActions center_mouse_action;   
        MouseActions left_mouse_action;     
        MouseActions right_mouse_action;    
        MouseActions wheel_mouse_action;    
 
    public:
        NDEVR_DESIGN_API void setNDEVRDefaults();
        NDEVR_DESIGN_API MouseAction getAction(const MouseEvent& event) const;
        NDEVR_DESIGN_API MouseActions& getDefaultAction(MouseEvent::MouseClickType type);
        NDEVR_DESIGN_API const MouseActions& getDefaultAction(MouseEvent::MouseClickType type) const;

        NDEVR_DESIGN_API bool processMouseEvent(MouseControllerEvent& event, SelectionInfo& info) override;

        NDEVR_DESIGN_API void addController(UUID id, MouseControllerBase* controller);
        NDEVR_DESIGN_API void removeController(UUID id);
        bool contextMenuRequested() const { return m_request_context_menu; }
        void resetContextMenuRequested() { m_request_context_menu = false; }
        bool selectionRequested() const { return m_request_selection; }
        void resetSelectionRequested() { m_request_selection = false; }
        const MouseEvent& lastMouseEvent() const { return m_last_mouse_event; }
        Resource<Buffer<UUID>> selected;        
        Resource<UUID> selected_layer;          
        Resource<UUID> focus;               
        Resource<String> cursor;            
        Resource<String> information;           
        Resource<uint04> number_of_mouse_events;    
        Resource<uint04> number_of_mouse_clicks;    
    private:
        Matrix<fltp08> m_parent_transform;  
        CameraAnimation m_original_camera;  
        Vector<2, fltp08> m_screen_percent_0;   
        fltp08 m_last_valid_distance;       
        bool m_is_dragging;         
        bool m_is_mouse_scrolling;      
        bool m_is_touch_scrolling;      
 
        MouseEvent m_last_mouse_event;      
    private:
 

        void getINI(INIFactory& factory) override;
        void setReferencePoint(ReferencePoint ref, Camera* camera);
        bool processGrips(MouseControllerEvent& event, const Buffer<UUID>& grips);
        //void updateCenterOfScreen(DesignObjectLookup* lookup);
        void updateCenterOfMouse(DesignObjectLookup* lookup, Camera* camera, SelectionInfo& selection, bool update_distance);
        void setView(MouseAction act, ReferencePoint ref, const Vector<2, fltp08>& screen_percent, Camera* camera);
        void mouseScrolled(fltp04 scroll_distance, Camera* camera);
        void touchScrolled(fltp04 scroll_distance, Camera* camera);
        void mouseClicked(const MouseEvent& e, DesignObjectLookup* lookup, Camera* camera);
        void mouseChangeView(const MouseEvent& e, Camera* camera);
    protected:
        bool m_request_context_menu;        
        bool m_request_selection;       
        bool m_ignore_next_event_if_click;  
        Dictionary<UUID, MouseControllerBase*> m_controller_lookup; 
        Buffer<MouseControllerBase*> m_controllers;         
        DynamicPointer<SnapController> m_snap_controller;       
    };
};
#endif