Selector.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: Selector
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/Material.h>
#include <NDEVR/SnapsManager.h>
#include <NDEVR/ModelIterator.h>
#include <NDEVR/DesignSelection.h>
#include <NDEVR/SelectionArea.h>
#include <functional>
 
namespace NDEVR
{
    enum class PrimitiveMode;
    struct GeometryVertices;

    class NDEVR_DESIGN_API SelectionInfo final : public ModelIterator
    {
    public:
        class ClosestModelInfo
        {
        public:
            ClosestModelInfo();

            void clear();

            NDEVR_DESIGN_API void setMaxDistance(fltp08 distance);

            void update(const SelectionArea<3, fltp08>& new_selection, const SelectionArea<3, fltp08>& old_selection);
        public:
            Matrix<fltp08> geometry_transform;  
            Vertex<3, fltp08> screen_location;  
            UUID nearest_geometry;              
            UUID nearest_model;                 
            UUID nearest_material;              
            UUID nearest_layer;                 
            fltp08 screen_distance;             
            uint04 nearest_index;               
            uint04 nearest_vertex;              
            bool is_smooth = false;             
        };

        SelectionInfo();

        void clear();

        void clearLastSelection();

        ParseResult process(Model& model) override;

        ParseResult postProcess(Model& model) override;

        ParseResult process(Model& model, Material& mat) override;

        ParseResult process(Model& model, Geometry& geo) override;

        bool processGeometry(const Model& model, const Geometry& geo, PrimitiveProperty primitive_property, UUID selection_id);

        fltp08 screenClosestDistanceSqr(bool outer_bound) const;

        fltp08 screenClosestDistanceSqr(PrimitiveMode mode) const;

        void setNearestGeometry(const Geometry& geo, PrimitiveMode primitive_mode, uint04 index, uint04 vertex);

        //returns true if recommended adjust line
        bool setNearestScreenPosition(PrimitiveMode mode, const Vertex<3, fltp08>& screen_point, fltp08 screen_distance);

        void setGeometryTransform(PrimitiveMode mode, const Matrix<fltp08>& mat);

        void setNearestModel(PrimitiveMode mode, const Model& model);

        void setNearestMaterial(PrimitiveMode mode, const UUID& material);

        void setNearestLayer(PrimitiveMode mode, const UUID& layer);

        void updateLineEndPoint(PrimitiveMode mode, Vertex<3, fltp08> vec);

        bool validModelSelection(const Model& model) const;

        void setAllowSolidInteraction(bool allow_solid_intersection) { m_allow_solid_intersection = allow_solid_intersection; }

        bool allowSolidInteraction() const { return m_allow_solid_intersection; }

        UUID nearestModel() const;

        Vertex<3, fltp08> nearestScreenLocation() const;

        Vertex<3, fltp08> nearestWorldLocation() const;

        UUID nearestGeometry(PrimitiveMode mode) const;

        void prepareSelection();

        void finishSelection();

        void getEnclosedVertices(GeometryVertices& vertices) const;

        void setCurrentSelection(const SelectionArea<3, fltp08>& new_selection);

        UUID uuid() const { return m_id; }

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

        Bounds<3, fltp08> selectionBounds() const;

        Bounds<3, fltp08> globalSelectionBounds() const;
 
        Material override_material;                             
        SelectionArea<3, fltp08> current_selection;             
        SelectionArea<3, fltp08> last_selection;                
        Buffer<SelectionArea<3, fltp08>> selection_masks;       
        LineSegment<3, fltp08> world_selection_line;                
        Vertex<3, fltp08> world_nearest_location;               
        Dictionary<UUID, EnclosedModelInfo> enclosed_info;      
        DesignSelection selection;                              
        ClosestModelInfo nearest_point;                         
        ClosestModelInfo nearest_line;                          
        ClosestModelInfo nearest_solid;                         
        WindingMode selection_winding_mode;                     
        fltp08 min_screen_cutoff_distance = 0.0;                
        fltp08 screen_point_bias = 0.0;                         
        fltp08 screen_line_bias = 0.0;                          
        UUID current_model = Constant<UUID>::Invalid;           
        UUID camera = Constant<UUID>::Invalid;                  
        Buffer<UUID> grips;                                     
        bool is_edit = false;                                   
        bool is_exact = true;                                   
        bool use_interaction_flag = true;                       
        bool mask_added = false;                                
        bool mask_subtracted = true;                            
        std::function<bool(const Model&)> selection_filter;     
    private:
        struct ProcessStruct
        {
            Geometry geo;                                       
            UUID selection_id;                                  
            SelectionArea<3, fltp08> selection;                 
            SelectionArea<3, fltp08> last_selection;            
            Buffer<SelectionArea<3, fltp08>> selection_masks;   
            PrimitiveProperty primitive_property;               
            PrimitiveMode primitive_mode;                       
            Buffer<uint04> indices;                             
            Buffer<bool> selection_mask;                            
            fltp04 max_distance;                                
        };

        void _processGeometryNoTree(ProcessStruct& geo);

        void _processGeometryWithTree(ProcessStruct& geo);

        bool _doesIntersect(const Model& model) const;

        bool _processLineSelection(ProcessStruct& pstruct);

        bool _processLineSelection(uint04 current_index, ProcessStruct& pstruct);

        bool _processPointSelection(ProcessStruct& pstruct);

        bool _processPointSelection(uint04 current_index, ProcessStruct& pstruct);
    protected:
        VertexIterator<Vertex<3, fltp04>> m_position_iter;          
        LineIterator<3, fltp04> m_line_position_iter;               
        TriangleIterator<3, fltp04> m_triangle_position_iter;       
        Buffer<Model> m_valid_model_stack;                          
        UUID m_id;                                                  
        bool m_allow_solid_intersection;                            
    };
}