EntityConverter.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: CAD
File: EntityConverter
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "../Headers/CADEntityStreamer.h"
#include "../Headers/CADHandleManager.h"
#include "../Headers/DXFValueManager.h"
#include "../Headers/EntityCodes.h"
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Model.h>
#include <NDEVR/ArcShape.h>
#include <NDEVR/ShapeConstructors.h>
#include <NDEVR/Text.h>
#include <NDEVR/MatrixFunctions.h>
#include <NDEVR/FactoryOptions.h>
#include <NDEVR/RWLock.h>
#include <NDEVR/ACIColor.h>
#include <NDEVR/Translator.h>
#include <NDEVR/UnitDefinitions.h>
namespace NDEVR
{
    static inline ConstPointer<Unit> ConvertFromCADUnit(uint04 cad_unit)
    {
        switch (cad_unit)
        {
        case 0:  return ConstPointer<Unit>();//No units
        case 1:  return UnitDefinitions::Inches(); break;
        case 2:  return UnitDefinitions::Feet(); break;
#if NDEVR_EXOTIC_UNITS
        case 3:  return UnitDefinitions::InternationalMiles(); break;
        case 8:  return UnitDefinitions::Microinches(); break;
        case 9:  return UnitDefinitions::Mils(); break;
        case 11: return UnitDefinitions::Angstrom(); break;
        case 12: return UnitDefinitions::Nanometers(); break;
        case 13: return UnitDefinitions::Microns(); break;
        case 14: return UnitDefinitions::Decimeters(); break;
        case 15: return UnitDefinitions::Dekameters(); break;
        case 16: return UnitDefinitions::Hectometers(); break;
        case 17: return UnitDefinitions::Gigameters(); break;
        case 18: return UnitDefinitions::AstronomicalUnits(); break;
        case 19: return UnitDefinitions::LightYears(); break;
        case 20: return UnitDefinitions::Parsecs(); break;
#endif
        case 4:  return UnitDefinitions::Millimeters(); break;
        case 5:  return UnitDefinitions::Centimeters(); break;
        case 6:  return UnitDefinitions::Meters(); break;
        case 7:  return UnitDefinitions::Kilometers(); break;
        case 10: return UnitDefinitions::Yards(); break;
        
        default: lib_assert(false, "Unknown unit"); return ConstPointer<Unit>();
        }
    }
    /*static uint04 ConvertToCADUnit(const ConstPointer<Unit>& cad_unit)
    {
        switch (cad_unit->name.hashLower())
        {
        default: return 0;
        case String::hash("inches"): return 1;
        case String::hash("feet"): return 2;
        case String::hash("international miles"): return 3;
        case String::hash("millimeters"): return 4;
        case String::hash("centimeters"): return 5;
        case String::hash("meters"): return 6;
        case String::hash("kilometers"): return 7;
        case String::hash("microinches"): return 8;
        case String::hash("mils"): return 9;
        case String::hash("yards"): return 10;
        case String::hash("angstroms"): return 11;
        case String::hash("nanometers"): return 12;
        case String::hash("microns"): return 13;
        case String::hash("decimeters"): return 14;
        case String::hash("dekameters"): return 15;
        case String::hash("hectometers"): return 16;
        case String::hash("gigameters"): return 17;
        case String::hash("astronomical_units"): return 18;
        case String::hash("light_years"): return 19;
        case String::hash("parsecs"): return 20;
        }
    }*/
    struct DimensionOptions
    {
        enum DimensionMode
        {
              e_scientific = 1              
            , e_decimal = 2                 
            , e_ngineering = 3              
            , e_architectural_stacked = 4   
            , e_fractional_stacked = 5      
            , e_architectural = 6           
            , e_fractional = 7              
 
        };
        ConstPointer<Unit> angle_unit = UnitDefinitions::Degrees();     
        uint04 angle_min_decimals;                                      
        ConstPointer<Unit> distance_unit = UnitDefinitions::Feet();     
        DimensionMode display_mode = DimensionMode::e_decimal;          
        fltp08 arrow_size = 2.0;                                        
        fltp08 dimension_scale_factor = 1.0;                            
        char decimal_seperator = '.';                                   
        String arrow_block_name;                                        
    };
    class CADMeshVertexAttributeSetter;
    class CADMeshVertexColorSetter;
    class EntityConverter : public CADEntityStreamer
    {
    public:
        EntityConverter(const File& relative_path, DesignObjectLookup* lookup, ProgressInfo& logger);
        virtual ~EntityConverter();
        void setHandleManager(const DynamicPointer<CADHandleManager>& handle_manager);
        void setupEntityMaterial(Model model);
        void endFaceSection();
        void endSection() final override;
        const ConstPointer<Unit>& unit() const;
        Material getMaterial();
        void addLayer(const LayerData& layer) final override;
        Scene paperRoot();
        Scene viewportRoot();
        String convertFromCADName(const String& file_name, const TranslatedString& object_type, uint04 object_count);
        void addDictionary(const CADDictionaryObject& dictionary) override;
        void addXRecord(const HandleData& record) override;
        void addXRecordData(uint04 value, DXFValueManager* value_manager) override;
        void addDXFMaterial(DXFMaterial& mat) override;
        Model getLayer(const String& layer_name);
        Material generateNewMaterial();
        Material getMaterial(const uint04& material_handle);
        virtual void addLinetype(const LineTypeData&) override;
        virtual void addLinetypeDash(double) override;
        Model getBlockModel(const String& block_name);
        void copyBlock(Model& model, Model& block);
        virtual void addGroup(const DXFGroup& group_info) override;
        virtual void addBlock(const BlockData& block_info) override;
        virtual void addViewport(const ViewportData& block_info) override;
        virtual void endBlock(const uint04&) override;
        void setupColorForGeoVertices();
        virtual void addTextStyle(const StyleData& text_style) override;
        virtual void addPoint(const PointData& point) override;
        void addLine(const LineData& line) override;
        void addXLine(const LineData& line) override;
        void addRay(const LineData& ray) override;
        virtual void addTrace(const TraceData& data) override;
        virtual void add3dFace(const TraceData& data) override;
        void addArc(const ArcData& arc) override;
#if NDEVR_TEXT_MODEL
        void addAttribute(const Attrib& attribute) override;
        void addAttributeDefinition(const Attrib& attribute) override;
        Text createFromTextData(const TextData& data, bool is_m_text);
        virtual void addText(const TextData& data) override;
#endif
        void addCircle(const CircleData& c) override;
        virtual void addEllipse(const EllipseData& e) override;
        virtual void addPolyline(const PolylineData& poly) override;
        virtual void addMesh(CADMeshData& mesh_data) override;
        virtual void addVertex(const Vector<4, fltp08>& vertex) override;
        virtual void addIndex(const Vector<4, sint04>& vertex) override;
        virtual void addInsert(const BlockInsert& data) override;
        virtual void addSpline(const SplineData&) override;
    #if NDEVR_VIEWPORT && NDEVR_MEASURE_MODELS
        void addDimAlign(const DimAlignedData& dimension) override;
        void addDimLinear(const LinearDimension& dimension) override;
    #endif
        void addDimRadial(const RadialDimension&) override;
        void addDimDiametric(const DiametricDimension&) override;
        void addDimAngular(const AngularDimensionData<3>&) override;
        void addDimAngular(const AngularDimensionData<4>&) override;
        void addDimOrdinate(const DimOrdinateData&) override;
        virtual void addLeader(const LeaderData& data) override;
        virtual void addComment(const StringView& comment) override;
    #if NDEVR_TEXT_MODEL
        void setupTextData(Text& text, const TextData& data, const Font& default_font, bool is_m_text);
    #endif
        virtual void endEntity() override;
        void setAttributes(const DXFAttributes&) override;
        void setExtrusion(fltp08 dx, fltp08 dy, fltp08 dz, fltp08 elevation) override;
        Extrusion& getExtrusion();
        Buffer<Model> modelRoots() const;
        Scene currentRoot();
        Model currentBlock();
        Buffer<TextBlock> parseString(const String& text, fltp08 default_height, const Font& start_font, bool is_m_text);
        void addBulge(Geometry& geo, fltp08 bulge, const Vertex<3, fltp08>& p1, const Vertex<3, fltp08>& p2);
        Geometry createGeometry(Model model = Model());
        Model currentEntity();
        void setVariableInt(const StringView& label, int value, int key_label) override;
        Model& currentLinework();
        Geometry& currentLineworkGeo();
        Geometry& currentTriMesh();
        Geometry& currentPolyMesh();
        Model& currentPoint();
        Geometry& currentCloudGeo();
        const Buffer<UUID>& pointsRead() const;
        const Buffer<UUID>& lineworkRead() const;
        const Buffer<UUID>& meshesRead() const;
 
        static Matrix<fltp08> GetOrientation(const Vector<3, fltp08>& extrusion);
    public:
        void setGroupImport(bool group_import);
        void setTextFacingCamera(bool text_face_camera);
        void setAutoNameObjects(bool auto_name_objects);
        void setPointMode(NDEVRFilePointMode mode);
        void setLineMode(DXFLineMode mode);
        void setIgnoreKnownBlocks(bool ignore_known_blocks);
        void setIgnoreKnownMaterials(bool ignore_known_materials);
        [[nodiscard]] Buffer<UUID> getAllReadEntities() const;
    private:
        void _addLayer(const LayerData& layer_data);
        void setupLayer(Model& model);
    #if NDEVR_TEXT_MODEL
        void getFont(const StringView& font_name, Font& font);
    #endif
    private:
        enum DXFMode
        {
            e_none
            , e_points
            , e_polyline
            , e_leader
            , e_line
            , e_closed_polyline
            , e_polyface
            , e_3D_face
            , e_3D_trace
            , e_measurement
        };
    #if NDEVR_TEXT_MODEL
        Dictionary<String, Font> m_loaded_fonts;
    #endif
        Dictionary<String, String> m_x_data;
        Dictionary<String, UUID> m_point_name_data;
        Dictionary<String, UUID> m_layers;
        Dictionary<String, StyleData> m_text_styles;
        Dictionary<String, UUID> m_blocks;
        Dictionary<String, Buffer<Model>> m_blocks_to_insert;
        Dictionary<UUID, String> m_child_blocks_to_insert;
        Dictionary<uint04, Material> m_materials;
        Vector<7, Geometry> m_measure_markers;
        Dictionary<uint04, UUID> m_mesh_object_dictionary_listeners;
        Dictionary<uint04, std::pair<UUID, VertexProperty>> m_mesh_object_field_listeners;
        Dictionary<uint04, std::pair<UUID, VertexProperty>> m_mesh_object_color_listeners;
        String m_current_block_name;
        String m_last_x_data_label;
        File m_relative_path;
        ConstPointer<Unit> m_unit;
        EntityData m_current_data;
        Buffer<Vertex<3, fltp08>> m_quad_position_data;
        Buffer<Vertex<3, fltp08>> m_tri_position_data;
        Buffer<RGBColor> m_quad_color_data;
        Buffer<RGBColor> m_tri_color_data;
        Buffer<UUID> m_model_roots;
        Buffer<UUID> m_linework_read;
        Buffer<UUID> m_points_read;
        Buffer<UUID> m_meshes_read;
        Buffer<UUID> m_blocks_read;
        Buffer<UUID> m_materials_read;
        UUID m_core_root = Constant<UUID>::Invalid;
        UUID m_current_paper_root = Constant<UUID>::Invalid;
        UUID m_current_viewport_root = Constant<UUID>::Invalid;
        UUID m_blocks_root = Constant<UUID>::Invalid;
        UUID m_current_block = Constant<UUID>::Invalid;
        UUID m_current_entity = Constant<UUID>::Invalid;
        UUID m_current_material = Constant<UUID>::Invalid;
        UUID m_last_insert = Constant<UUID>::Invalid;
        Geometry m_current_geometry;
        Model m_current_linework;
        Geometry m_current_linework_geo;
        Geometry m_current_mesh;
        Geometry m_current_points;
        Model m_current_point;
        NDEVRFilePointMode m_point_mode = NDEVRFilePointMode::e_point;
        DXFLineMode m_line_mode = DXFLineMode::e_line;
        DynamicPointer<CADHandleManager> m_handle_manager;
        DesignObjectLookup* m_model_lookup = nullptr;
        CADMeshVertexAttributeSetter* m_mesh_attribute_setter = nullptr;
        CADMeshVertexColorSetter* m_mesh_color_setter = nullptr;
        
        Vertex<3, fltp08> m_position_offset = Constant<Vertex<3, fltp08>>::Invalid;
        std::function<void(uint04 value, DXFValueManager* manager)> m_xdata_callback;
        fltp08 m_next_bulge = Constant<fltp08>::Invalid;
        uint04 m_circle_count = 0U;
        uint04 m_ellipse_count = 0U;
        uint04 m_insert_count = 0U;
        uint04 m_attribute_count = 0U;
        DimensionOptions m_dim_options;
        DXFMode m_current_mode = DXFMode::e_none;
        bool m_color_by_vertex = false;
        bool m_group_import = true;
        bool m_text_face_camera = false;
        bool m_auto_name_objects = true;
        bool m_ignore_known_blocks = true;
        bool m_ignore_known_materials = false;
        bool m_ignore_current = false;//when true, ignores any information
    };
}