Selector.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
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();
        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();
        void pushTransform(const Matrix<fltp08>& transform, bool apply_to_original);
        void popTransform();
        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 Geometry& geo, PrimitiveProperty primitive_property);
        
        fltp08 screenClosestDistanceSqr(bool outer_bound) const;
        fltp08 screenClosestDistanceSqr(PrimitiveMode mode) const;
        fltp08 localClosestDistanceSqr(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 getEnclosedVertices(GeometryVertices& vertices) const;
        
        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;
        Buffer<SelectionArea<3, fltp08>> selection_masks;
        LineSegment<3, fltp08> world_selection_line;//screen space
        Vertex<3, fltp08> world_nearest_location;
        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>::NaN;
        UUID camera = Constant<UUID>::NaN;
        UUID grips = Constant<UUID>::NaN;
        bool is_edit = false;
        bool is_exact = true;
        bool use_interaction_flag = true;
        bool mask_added = false;
        bool mask_subtracted = true;
        bool allow_inverse_trans = false;
        std::function<bool(const Model&)> selection_filter;//Once a selection is made, filters the appropriate parent, returns true if selectable
    protected:
        struct ProcessStruct
        {
            Geometry geo;
            SelectionArea<3, fltp08> perspective_selection;
            SelectionArea<3, fltp08> linear_selection;
            PrimitiveProperty primitive_property;
            PrimitiveMode primitive_mode; 
            Buffer<uint04> indices;
            Buffer<bool> selection_mask; 
            fltp04 linear_distance;
            fltp04 perspective_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);
    protected:
        Buffer<Model> m_valid_model_stack;
        Buffer<Matrix<fltp08>> m_pushed_transforms;
        Buffer<Buffer<Matrix<fltp08>>> m_pushed_mask_transforms;
        UUID m_id;
        bool m_allow_solid_intersection;
    };
}