ModelEditController.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: ModelEditController
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/SnapController.h>
#if NDEVR_VIEWPORT
#include <NDEVR/CommandLockObject.h>
#include <NDEVR/SelectionController.h>
 
namespace NDEVR
{
    class ModelEditController;
    class NDEVR_DESIGN_API ModelFunction
    {
        friend class ModelEditController;
    public:
        TranslatedString name;  
        String icon;            
        UUID id;                
 
        virtual ~ModelFunction(){};

        virtual TranslatedString group() const;

        virtual TranslatedString hint() const { return TranslatedString(); };

        virtual TranslatedString expandedHint() const { return TranslatedString(); };

        virtual bool selectionModeAllowed(const SubSelectionMode& mode) const = 0;

        virtual bool processMouseEvent(MouseControllerEvent&) { return false; }

        virtual bool processKeyEvent(const KeyEvent&, DesignObjectLookup*, Camera*) { return false; }

        virtual void refreshState(ModelEditController& controller) = 0;

        virtual bool canAutoFinishNow() const { return false; };

        virtual SubSelectionMode defaultSelectionMode() const = 0;

        virtual void setupFilters(SelectionController*) {}

        virtual void onSelect(const Buffer<UUID>&) {}

        virtual bool isSelecting() const = 0;

        virtual void onCancel() = 0;

        virtual void requestCancel();

        virtual void requestFinish();

        virtual bool shouldShowInterface() const { return false; }

        virtual void requestFinishSelection();
 
    protected:
        virtual void setController(ModelEditController* controller);
 
        ModelEditController* m_controller = nullptr;    
    };

    class NDEVR_DESIGN_API ModelEditController : public SnapController
    {
    public:
        enum ModelEditMode : uint04
        {
              e_no_edit                 
            , e_center_locked_scale     
            , e_center_scale            
            , e_two_point_locked_scale  
            , e_two_point_scale         
            , e_two_length_scale        
            , e_offset                  
            , e_vertex_offset           
            , e_rotate                  
            , e_place_and_rotate        
            , e_place_no_rotate         
            , e_flip_left               
            , e_flip_front              
            , e_flip_vertical           
 
            , e_set_real_thickness      
 
            , e_rubber_stamp            
            , e_erase                   
 
            , e_add_selection_mask      
            , e_edit_mode_size          
            , e_model_function          
        };

        ModelEditController(DesignObjectLookup* manager);
 
        ModelEditController(const ModelEditController&) = delete;
 
        virtual ~ModelEditController(){};

        virtual void begin() override;

        virtual void finish() override;

        virtual void cancel() override;

        bool hasCommandLock() const { return m_command_lock.isLocked(); }

        const UUID& material() const { return m_paint_material; }

        const UUID& pasteModel() const { return m_paste_model; }

        Model activeModel() const { return m_current_model; }

        UUID activeModelFunction() const;

        void setPasteModel(UUID model);

        void setActiveModel(UUID model);

        void addEditFunction(const DynamicPointer<ModelFunction>& function);

        void setActiveEditFunction(const UUID& function);

        const Dictionary<UUID, DynamicPointer<ModelFunction>>& editFunctions() const { return m_edit_functions; };

        void setActiveVertex(const Matrix<fltp08>& complete_transform, UUID geometry, uint04 vertex_id);

        void refreshState();

        void addPoint(const Vertex<3, fltp08>& point) override;

        virtual void updateLocation(const Vertex<3, fltp08>& location, bool is_select = false, Camera* camera = nullptr) override;

        bool selectionModeAllowed(const SubSelectionMode& mode) const;

        bool shouldShowInterface() const;

        TranslatedString title() const;

        TranslatedString hint() const;

        TranslatedString expandedHint() const;

        SubSelectionMode defaultSelectionMode() const;
 
        Resource<ModelEditMode> edit_mode;  

        Buffer<UUID> editedModels() { return m_edited_models; }

        bool tryCommandLock();

        Matrix<fltp08> originalTransform() const { return m_original_matrix; }

        void setOriginalTransform(const Matrix<fltp08>& transform);

        void setupSelectionInfo(const MouseEvent& event, Camera* camera, SelectionInfo& info) override;

        virtual void addPoint(const SnapPoint& point) override;

        virtual void addNextFinishedCallback(std::function<void(bool canceled, UUID id)> callback) { m_next_finished_callback = callback; }

        bool isSelecting() const;

        void finishSelection();

        void setAutoFinish(bool auto_finish);

        void setUseGravity(bool use_gravity);

        bool usingGravity() const;

        bool hasFinishedMouseActions() const;

        Matrix<fltp08> gravityAdjust(const Matrix<fltp08>& mat) const;
 
    protected:
        void refreshOffsetState();

        void refreshPlaceState();

        void refreshVertexOffsetState();

        void refreshScaleState();

        void refreshRotateState();

        void refreshRealThicknessState();

        void refreshTwoPointSelectState();

        void setSelectionFilters();

        void onSelect(UUID object);

        void onMouseSelect();

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

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

        void updateGravityPoints();
 
    protected:
        CommandLockObject m_command_lock;                   
        UUID m_paint_material;                              
        UUID m_paste_model;                                 
        Model m_current_model;                              
        UUID m_current_geometry;                            
        uint04 m_current_vertex;                            
        Buffer<UUID> m_edited_models;                       
        Matrix<fltp08> m_original_matrix;                   
        Vector<2, sint02> m_mouse_screen_original;          
        Vector<3, fltp08> m_mouse_scene_original;           
        Plane<3, fltp08> m_command_plane;                   
        Buffer<Vertex<3, fltp08>> m_gravity_points;         
        bool m_snap_to_normal;                              
        bool m_yaw_to_normal;                               
        bool m_lock_scale;                                  
        bool m_ignore_elevation;                            
        bool m_is_selecting;                                
        bool m_auto_finish;                                 
        bool m_use_gravity;                                 
        std::function<void(bool canceled, UUID id)> m_next_finished_callback;   
        Dictionary<UUID, DynamicPointer<ModelFunction>> m_edit_functions;       
        DynamicPointer<ModelFunction> m_active_edit_function;                   
    };
}
#endif