CADEntities.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: CAD
File: CADEntities
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <utility>
#include "Base/Headers/File.h"
#include "Base/Headers/Angle.h"
#include "Base/Headers/Line.hpp"
#include "Base/Headers/Font.h"
#include "Base/Headers/RGBColor.h"
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Modes that CAD can use to color objects
    **/
    enum ColorMode
    {
          e_use
        , e_by_block
        , e_by_layer
        , e_background_contrast//aci = 7
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores CAD details about PaperSpace or 2D document space
    **/
    struct PaperSpace
    {
        Bounds<3, fltp08> model_space_bounds = Bounds<3, fltp08>(Constant<Vertex<3, fltp08>>::Invalid);
        Bounds<3, fltp08> paper_space_bounds = Bounds<3, fltp08>(Constant<Vertex<3, fltp08>>::Invalid);
        Vertex<3, fltp08> paper_space_origin = Vertex<3, fltp08>(0.0);
        Matrix<fltp08> paperToModelMatrix() const
        {
            Matrix<fltp08> mat(1.0);
            if (IsInvalid(model_space_bounds) || IsInvalid(paper_space_bounds))
                return mat;
            mat = mat.offset(model_space_bounds[MIN]);
            Vector<3, fltp08> scale = model_space_bounds.span() / paper_space_bounds.span();
            if (paper_space_bounds.span()[Z] == 0.0 || scale[Z] == 0.0)
                scale[Z] = 0.0001;
            mat = mat.scale(scale);
            mat = mat.offset(paper_space_origin);
            return mat;
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores color information for interfacing with CAD
    **/
    struct CADColorInfo
    {
        ColorMode mode = e_use;
        RGBColor color = Constant<RGBColor>::Invalid;
        bool operator==(const CADColorInfo& other) const
        {
            return mode == other.mode && color == other.color;
        }
        bool operator!=(const CADColorInfo& other) const
        {
            return mode != other.mode || color != other.color;
        }
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A variable shared between NDEVR and CAD
    **/
    struct CADVariable
    {
        enum CADVARType
        {
              e_double
            , e_int
            , e_string
        };
        CADVariable()
            : var_type(e_string)
        {}
        CADVariable(const String& label)
            : label(label)
        {}
        CADVariable(const String& label, sint04 key_label, const fltp08& value)
            : label(label)
        {
            var_type = CADVARType::e_double;
            values.add({key_label , String(value) });
        }
        CADVariable(const String& label, sint04 key_label, const uint04& value)
            : label(label)
        {
            var_type = CADVARType::e_int;
            values.add({ key_label , String(value) });
        }
        CADVariable(const String& label, sint04 key_label, const String& value)
            : label(label)
        {
            var_type = CADVARType::e_string;
            values.add({ key_label , String(value) });
        }
        CADVariable(const String& label, Vector<2, fltp08> data)
            : label(label)
        {
            var_type = CADVARType::e_double;
            values.add({ 10 , String(data[X]) });
            values.add({ 20 , String(data[Y]) });
        }
        CADVariable(const String& label, Vector<3, fltp08> data)
            : label(label)
        {
            var_type = CADVARType::e_double;
            values.add({ 10 , String(data[X]) });
            values.add({ 20 , String(data[Y]) });
            values.add({ 30 , String(data[Z]) });
        }
        String label;
        Buffer<std::pair<sint04, String>> values;
        CADVARType var_type;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A handle used to reference an object in CAD
    **/
    struct HandleData
    {
        uint04 handle = Constant<uint04>::Invalid;
        uint04 parent_handle = Constant<uint04>::Invalid;
        uint04 file_line_number = Constant<uint04>::Invalid;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief An entity in CAD which has a layer and other handle information
    **/
    struct EntityData : public HandleData
    {
        String layer;
        String line_type;
        CADColorInfo color_info;
        fltp08 line_type_scale = 1.0;
        PaperSpace paper_space_info;
        uint04 material_handle = Constant<uint04>::Invalid;
        uint04 file_line_number = Constant<uint04>::Invalid;
        bool is_off = false;
        bool visible = true;
        bool paper_space = false;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Layer information shared with CAD
    **/
    struct LayerData : public EntityData
    {
        enum LayerFlags
        {
              e_frozen
            , e_frozen_by_default
            , e_locked
        };
        LayerData()
        {}
        LayerData(String name, const Vector<8, bool>& flags)
            : name(std::move(name))
            , flags(flags)
        {}
        String name;
        Vector<8, bool> flags = Vector<8, bool>(false);
    };
    
    /**--------------------------------------------------------------------------------------------------
    \brief A block structure (Similar to a Model) used to share data with CAD.
    **/
    struct BlockData : public LayerData
    {
        BlockData()
        {}
        BlockData(String name, const Vector<8, bool>& flags)
            : LayerData(std::move(name), flags)
        {}
        Vertex<3, fltp08> offset = Vertex<3, fltp08>(0.0);
        String description;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Data for extruding an object onto a plane in CAD
    **/
    struct ExtrusionData
    {
        Vector<3, fltp08> extrusion = Vector<3, fltp08>(0.0, 0.0, 1.0);
        fltp08 elevation = 0.0;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief information for a type of line in CAD
    **/
    struct LineTypeData
    {
        LineTypeData(const String& name, const String& description, int flags, uint04 numberOfDashes, double patternLength)
            : name(name)
            , description(description)
            , flags(flags)
            , number_of_dashes(numberOfDashes)
            , pattern_length(patternLength)
        {}
        LineTypeData(const String& name, const String& description, int flags, uint04 numberOfDashes, double patternLength, const Buffer<fltp08>& pattern)
            : name(name)
            , description(description)
            , flags(flags)
            , number_of_dashes(numberOfDashes)
            , pattern_length(patternLength)
            , pattern(pattern)
        {}
        String name;
        String description;
        Vector<32, bool> flags;
        uint04 number_of_dashes;
        fltp08 pattern_length;
        Buffer<fltp08> pattern;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a style data in a CAD-friendly way for exporting and importing.
    **/
    struct StyleData
    {
        StyleData()
            : name()
            , flags(0)
            , fixed_text_height(Constant<fltp08>::Invalid)
            , width_factor(1.0)
            , oblique_angle(0.0)
            , text_generation_flags(0)
            , last_height_used(Constant<fltp08>::Invalid)
            , primary_font_file(File())
            , big_font_file(File())
            , bold(false)
            , italic(false)
        {}
        StyleData(const String& name, int flags, double fixedTextHeight, double widthFactor, double obliqueAngle,
            int textGenerationFlags, double lastHeightUsed, const String& primaryFontFile, const String& bigFontFile)
            : name(name)
            , flags(flags)
            , fixed_text_height(fixedTextHeight)
            , width_factor(widthFactor)
            , oblique_angle(obliqueAngle)
            , text_generation_flags(textGenerationFlags)
            , last_height_used(lastHeightUsed)
            , primary_font_file(primaryFontFile)
            , big_font_file(bigFontFile)
            , bold(false)
            , italic(false)
        {}
 
        bool operator==(const StyleData& other) const
        {
            // ignore lastHeightUsed:
            return (name == other.name && flags == other.flags && fixed_text_height == other.fixed_text_height &&
                width_factor == other.width_factor && oblique_angle == other.oblique_angle && /*textGenerationFlags == other.textGenerationFlags &&*/
                primary_font_file == other.primary_font_file && big_font_file == other.big_font_file);
        }
        String name;
        int flags;
        fltp08 fixed_text_height;
        fltp08 width_factor;
        fltp08 oblique_angle;
        Vector<32, bool> text_generation_flags;
        fltp08 last_height_used;
        String primary_font_file;
        String big_font_file;
        bool bold;
        bool italic;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a arc data in a CAD-friendly way for exporting and importing.
    **/
    struct ArcData : public ExtrusionData, public EntityData
    {
        ArcData(const Vector<3, fltp08>& center_point, fltp08 aRadius, Angle<fltp08> aAngle1, Angle<fltp08> aAngle2)
            : offset(center_point)
            , radius(aRadius)
            , thickness(Constant<fltp08>::Invalid)
            , angle1(aAngle1)
            , angle2(aAngle2)
        {}
 
        Vector<3, fltp08> offset;
        fltp08 radius;
        fltp08 thickness;
        Angle<fltp08> angle1;
        Angle<fltp08> angle2;
    };
    
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a polyline data in a CAD-friendly way for exporting and importing.
    **/
    struct PolylineData : public ExtrusionData, public EntityData
    {
        enum PolyFlags
        {
              e_closed//This is a closed polyline (or a polygon mesh closed in the M direction).
            , e_curve_fits//Curve-fit vertices have been added.
            , e_spline_fits//Spline-fit vertices have been added.
            , e_is_3D_polyline//This is a 3D polyline.
            , e_is_3D_polygon//This is a 3D polygon mesh.
            , e_is_closed_n//The polygon mesh is closed in the N direction.
            , e_is_polyface_mesh//The polyline is a polyface mesh.
            , e_line_continuous//The linetype pattern is generated continuously around the vertices of this polyline.
        };
        enum CurveType
        {
              e_no_smooth = 0
            , e_quadratic_b = 5
            , e_cubic = 6
            , e_bezier = 8
        };
        fltp08 thickness = 0.0;
        fltp08 start_width = 0.0;
        fltp08 end_width = 0.0;
        CurveType curve_type = CurveType::e_no_smooth;
        uint04 vertex_count = Constant<uint04>::Invalid;
        uint04 m = Constant<uint04>::Invalid;//Number of vertices in m direction if polyline is a polygon mesh.
        uint04 n = Constant<uint04>::Invalid;//Number of vertices in n direction if polyline is a polygon mesh.
        Vector<32, bool> flags = Vector<32, bool>(false);
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a trace data in a CAD-friendly way for exporting and importing.
    **/
    struct TraceData : public ExtrusionData, public EntityData
    {
        TraceData()
            : thickness(0.0)
            , is_solid(false)
        {}
        Vertex<3, fltp08> points[4] = {Constant<Vector<3, fltp08>>::Invalid, Constant<Vector<3, fltp08>>::Invalid, Constant<Vector<3, fltp08>>::Invalid, Constant<Vector<3, fltp08>>::Invalid };
        fltp08 thickness = 0.0;
        bool is_solid = false;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a spline data in a CAD-friendly way for exporting and importing.
    **/
    struct SplineData : public EntityData
    {
        SplineData(uint01 degree, const Vector<32, bool>& flags)
            : degree(degree)
            , flags(flags)
        {
 
        }
 
        uint01 degree;
        Vector<32, bool> flags;
        Vector<3, fltp08> tangent_start;
        Vector<3, fltp08> tangent_end;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores mesh data in a way optimized for CAD
    **/
    struct CADMeshData : public EntityData
    {
        enum PropertyOverrideType
        {
            e_color = 0
            , e_material = 1
            , e_transparency = 2
            , e_material_mapper = 3
        };
        CADMeshData()
        {}
        struct MeshOverride
        {
            uint04 sub_entity_marker = 0;
            PropertyOverrideType type = e_color;
            Buffer<fltp08> values;
 
        };
        Buffer<Vertex<3, fltp08>> vertices;
        Buffer<Vertex<3, fltp08>> normals;
        Buffer<Vertex<3, fltp08>> textures;
        Buffer<RGBColor> colors;
        Buffer<uint04> face_points;
        Buffer<uint04> edge_points;
        Buffer<fltp08> edge_crease_values;
        Buffer<MeshOverride> property_overrides;
        uint04 version_number = 2;
        uint04 subdivide_level = 0;
        uint04 data_dictionary_reference = Constant<uint04>::Invalid;
        bool bend_crease = false;//72
 
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores text data that may have an attachment point and direction for interfacing with CAD
    **/
    struct MTextData
    {
        MTextData(Vector<3, fltp08> insertion_point, Vector<3, fltp08> direction,
            Vector<2, fltp08> size, int attachmentPoint, int drawingDirection,
            int lineSpacingStyle, fltp04 lineSpacingFactor, const String& text, const String& style, Angle<fltp08> angle)
            : insertion_point(insertion_point)
            , direction_vector(direction)
            , text_size(size)
            , attachment_point(attachmentPoint)
            , drawing_direction(drawingDirection)
            , line_spacing_style(lineSpacingStyle)
            , line_spacing_factor(lineSpacingFactor)
            , text(text)
            , style(style)
            , angle(angle)
        {}
        Vector<3, fltp08> insertion_point;
        Vector<3, fltp08> direction_vector;
        Vector<2, fltp08> text_size;
        /**
         * Attachment point.
         *
         * 1 = Top left, 2 = Top center, 3 = Top right,
         * 4 = Middle left, 5 = Middle center, 6 = Middle right,
         * 7 = Bottom left, 8 = Bottom center, 9 = Bottom right
         */
        int attachment_point;
        int drawing_direction;//1 = left to right, 3 = top to bottom, 5 = by style
        int line_spacing_style;//1 = at least, 2 = exact
        fltp04 line_spacing_factor;//0.25 - 4.0  
        String text;
        String style;
        Angle<fltp08> angle;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a text data in a CAD-friendly way for exporting and importing.
    **/
    struct TextData : public ExtrusionData, public EntityData
    {
        String text;
        String style;
        Vertex<3, fltp08> align_a = Constant< Vector<3, fltp08>>::Invalid;
        Vertex<3, fltp08> align_b = Constant< Vector<3, fltp08>>::Invalid;
        fltp08 height = Constant<fltp08>::Invalid;
        fltp08 reference_width = Constant<fltp08>::Invalid;
        fltp08 thickness = Constant<fltp08>::Invalid;
        Angle<fltp08> rotatation = Angle<fltp08>(0);
        Angle<fltp08> oblique_angle = Angle<fltp08>(0);
        fltp08 x_scale = 1.0;
        fltp08 line_spacing_factor = 1.0;
        uint01 flags = 0;
        uint01 alignment = 0;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a attribue data in a CAD-friendly way for exporting and importing.
    **/
    struct Attrib : public TextData
    {
        enum Flags
        {
            e_attribute_invisible
            , e_constant_attribute
            , e_verification_required
            , e_no_prompt_on_insertion
        };
        String tag;
        String default_value;
        BitFlag attrib_flags = BitFlag(0);
        bool is_locked = false;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a circle data in a CAD-friendly way for exporting and importing.
    **/
    struct CircleData : public ExtrusionData, public EntityData
    {
        RadialObject<3, fltp08> circle;
        fltp08 thickness = Constant<fltp08>::Invalid;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores Ellipse information for interfacing with CAD
    **/
    struct EllipseData : public ExtrusionData, public EntityData
    {
        Vertex<3, fltp08> center;
        Vertex<3, fltp08> endpoint_of_major_axis;
        fltp08 thickness = Constant<fltp08>::Invalid;
        fltp08 minor_to_major_ratio;
        Angle<fltp08> angle1;
        Angle<fltp08> angle2;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A CAD-friendly way to store line segment information.
    **/
    struct LineData : public ExtrusionData, public EntityData
    {
        LineSegment<3, fltp08> line;
        fltp08 thickness = 0.0;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Data about where to place an object, used for interfacing with CAD.
    **/
    struct PlacementData : public ExtrusionData
    {
        Vector<3, fltp08> offset = Vector<3, fltp08>(0.0);
        Vector<3, fltp08> scale = Constant<Vector<3, fltp08>>::Invalid;
        Angle<fltp08> azimuth = Constant<Angle<fltp08>>::Invalid;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Information for how to place a CAD block within a scene (Similar to Model).
    **/
    struct BlockInsert : public PlacementData, public EntityData
    {
        String block_name;
        Vector<2, uint04> grid_count = Constant<Vector<2, uint04>>::Invalid;
        Vector<2, fltp08> grid_spacing = Constant<Vector<2, fltp08>>::Invalid;
        bool attribute_to_follow;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Point data stored in a friendly way for interfacing with CAD.
    **/
    struct PointData : public ExtrusionData, public EntityData
    {
        Vector<3, fltp08> location;
        Angle<fltp08> effect_angle = Angle<fltp08>(DEGREES, 0.0f);
        fltp08 thickness = 0.0;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Dimensional measurements stored in a CAD-friendly way.
    **/
    struct DimensionData : public ExtrusionData, public EntityData
    {
        Vector<3, fltp08> definition_point;
        Vector<3, fltp08> text_middle_point;
        /**
         * Dimension type.
         *
         * 0   Rotated, horizontal, or vertical
         * 1   Aligned
         * 2   Angular
         * 3   Diametric
         * 4   Radius
         * 5   Angular 3-point
         * 6   Ordinate
         * 64  Ordinate type. This is a bit value (bit 7)
         *     used only with integer value 6. If set,
         *     ordinate is X-type; if not set, ordinate is
         *     Y-type
         * 128 This is a bit value (bit 8) added to the
         *     other group 70 values if the dimension text
         *     has been positioned at a user-defined
         *    location rather than at the default location
         */
        int type;
        uint01 attachment_point_align = 5;
        int line_spacing_style;//1 = at least, 2 = exact
        fltp08 line_spacing_factor;//line spacing factor 0.25-4.0
        String text;//Text string entered explicitly by user or "<>" for the actual measurement or " " (one blank space). for supressing the text.
        String dimension_style;// Dimension style (font name)
        Angle<fltp08> angle;//Rotation angle of dimension text away from default orientation.
        double linear_factor;//style override.
        double dim_scale;//scale
        Angle<fltp08> text_angle;
        Angle<fltp08> dim_hor_angle;
        String dimension_block_name;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A CAD measurement similar to AngleMeasurementModel
    **/
    struct DimAlignedData : public DimensionData
    {
 
        DimAlignedData()
        {}
 
        LineSegment<3, fltp08> alignment_data;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief A CAD measurement similar to DistanceMeasurementModel
    **/
    struct LinearDimension : public DimensionData
    {
        LinearDimension()
        { }
        
        LineSegment<3, fltp08> alignment_data;
 
        Angle<fltp08> line_angle; //Rotation angle of dimension line. 
        Angle<fltp08> oblique_angle;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A container for information pointing to a CAD dictionary in CAD memory.
    **/
    struct CADDictionaryObject
    {
        uint04 handle = Constant<uint04>::Invalid;
        uint04 parent_handle = 0;
        bool hard_owned = true;
        Buffer<CADVariable> data;
        void clear()
        {
            handle = Constant<uint04>::Invalid;
            parent_handle = 0;
            data.clear();
        }
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a radial dimension in a CAD-friendly way for exporting and importing.
    **/
    struct RadialDimension : public DimensionData
    {
        RadialDimension(const Vector<3, fltp08>& coordinate, fltp08 dleader)
            : coordinate(coordinate)
            , leader(dleader)
        {}
 
        Vector<3, fltp08> coordinate;
        fltp08 leader;//Leader length
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing an diametric dimension in a CAD-friendly way for exporting and importing.
    **/
    struct DiametricDimension : public DimensionData
    {
        DiametricDimension(const Vector<3, fltp08>& def_point, double dleader)
            : def_point(def_point)
            , leader(dleader)
        {}
        Vector<3, fltp08> def_point;
        fltp08 leader;//Leader length
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing an angular dimension in a CAD-friendly way for exporting and importing.
    **/
    template<uint04 t_data_count>
    struct AngularDimensionData : public DimensionData
    {
        AngularDimensionData(const Vector<3, fltp08>& def_point_1, const Vector<3, fltp08>& def_point_2, const Vector<3, fltp08>& def_point_3)
        {
            static_assert(t_data_count == 3, "Wrong Argument Count");
            def_points[0] = def_point_1;
            def_points[1] = def_point_2;
            def_points[2] = def_point_3;
        }
        AngularDimensionData(const Vector<3, fltp08>& def_point_1, const Vector<3, fltp08>& def_point_2,
            const Vector<3, fltp08>& def_point_3, const Vector<3, fltp08>& def_point_4)
        {
            static_assert(t_data_count == 4, "Wrong Argument Count");
            def_points[0] = def_point_1;
            def_points[1] = def_point_2;
            def_points[2] = def_point_3;
            def_points[3] = def_point_4;
        }
        Vector<3, fltp08> def_points[t_data_count];
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing an ordinate dimension in a CAD-friendly way for exporting and importing.
    **/
    struct DimOrdinateData : public LineSegment<3, fltp08>, public DimensionData
    {
        DimOrdinateData(const Vector<3, fltp08>& p1, const Vector<3, fltp08>& p2, bool type)
            : LineSegment<3, fltp08>(p1, p2)
            , xtype(type)
        {}
 
        DimOrdinateData(LineSegment<3, fltp08>& dimension, bool type)
            : LineSegment<3, fltp08>(dimension)
            , xtype(type)
        {}
        bool xtype;//True if the dimension indicates the X-value, false for Y-value
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a leader in a CAD-friendly way for exporting and importing.
    **/
    struct LeaderData : public EntityData
    {
        enum LeaderPathType
        {
            e_segments = 0
            , e_spline = 1
        };
        LeaderData()
            : text_annotation_size(Constant<fltp08>::Invalid)
            , use_arrowhead(false)
            , leader_path_type(e_segments)
            , leader_creation_flag(BitFlag(0))
            , hookline_direction_flag(BitFlag(0))
            , hookline_flag(BitFlag(0))
        {}
        LeaderData(bool lArrowHeadFlag, LeaderPathType lLeaderPathType, int lLeaderCreationFlag, int lHooklineDirectionFlag
            , int lHooklineFlag, fltp08 lTextAnnotationHeight, fltp08 lTextAnnotationWidth)
            : text_annotation_size(lTextAnnotationWidth, lTextAnnotationHeight)
            , use_arrowhead(lArrowHeadFlag)
            , leader_path_type(lLeaderPathType)
            , leader_creation_flag(lLeaderCreationFlag)
            , hookline_direction_flag(lHooklineDirectionFlag)
            , hookline_flag(lHooklineFlag)
        {}
        
        Vector<2, fltp08> text_annotation_size;//Text annotation size
        bool use_arrowhead;//Arrow head flag
        LeaderPathType leader_path_type;//Leader path type
        BitFlag leader_creation_flag;//Leader creation flag
        BitFlag hookline_direction_flag;//direction flag
        BitFlag hookline_flag;//Hookline flag
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a hatch-data in a CAD-friendly way for exporting and importing.
 
    Hatch patterns in CAD play an important role in architectural and mechanical drawings as they can be 
        used to identify and locate different types of materials, objects and space, to show materials used, 
        surface qualities, or add realism to a drawing.
    **/
    struct HatchData
    {
        HatchData()
            : pattern_origin(Constant<Vector<2, fltp08>>::Invalid)
            , scale(Constant<fltp08>::Invalid)
            , num_loops(Constant<uint04>::Invalid)
            , is_solid(false)
        {}
 
        HatchData(uint04 numLoops, bool solid, fltp08 scale, const Angle<fltp08>& angle, String pattern, const Vector<2, fltp08>& origin)
            : pattern_origin(origin)
            , pattern_name(std::move(pattern))
            , scale(scale)
            , num_loops(numLoops)
            , angle(angle)
            , is_solid(solid)
        {}
        Vector<2, fltp08> pattern_origin;
        String pattern_name;
        fltp08 scale;
        uint04 num_loops;
        Angle<fltp08> angle;
        bool is_solid;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Provides loops of data for the CAD hatch pattern.
    **/
    struct HatchLoopData
    {
        HatchLoopData()
            : num_of_edges(Constant<uint04>::Invalid)
        {}
        HatchLoopData(uint04 num_edges)
            : num_of_edges(num_edges)
        {}
        uint04 num_of_edges;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information about the edge of a CAD hatch pattern.
    **/
    struct HatchEdgeData
    {
        HatchEdgeData()
            : line(Constant<LineSegment<2, fltp08>>::Invalid)
            , center_point(Constant<Vector<2, fltp08>>::Invalid)
            , start_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , end_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , axis_major_point(Constant<Vector<2, fltp08>>::Invalid)
            , radius(Constant<fltp08>::Invalid)
            , axis_ratio(Constant<fltp08>::Invalid)
            , type(e_undefined)
            , degree(0)
            , rational(false)
            , periodic(false)
            , is_ccw(false)
        {}
        explicit HatchEdgeData(LineSegment<2, fltp08> line)
            : line(std::move(line))
            , center_point(Constant<Vector<2, fltp08>>::Invalid)
            , start_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , end_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , axis_major_point(Constant<Vector<2, fltp08>>::Invalid)
            , radius(Constant<fltp08>::Invalid)
            , axis_ratio(Constant<fltp08>::Invalid)
            , type(e_line)
            , degree(0)
            , rational(false)
            , periodic(false)
            , is_ccw(false)
        {}
 
        HatchEdgeData(const Vector<2, fltp08>& arc_center, fltp08 radius, Angle<fltp08> angle_start, Angle<fltp08> angle_end, bool ccw)
            : line(Constant<LineSegment<2, fltp08>>::Invalid)
            , center_point(arc_center)
            , start_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , end_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , axis_major_point(Constant<Vector<2, fltp08>>::Invalid)
            , radius(radius)
            , angle_start(angle_start)
            , angle_end(angle_end)
            , axis_ratio(Constant<fltp08>::Invalid)
            , type(e_arc)
            , degree(0)
            , rational(false)
            , periodic(false)
            , is_ccw(ccw)
        {}
 
        HatchEdgeData(const Vector<2, fltp08>& center, const Vector<2, fltp08>& axis_major_point, double ratio, Angle<fltp08> angle1, Angle<fltp08> angle2, bool ccw)
            : line(Constant<Vector<2, fltp08>>::Invalid, Constant<Vector<2, fltp08>>::Invalid)
            , center_point(center)
            , start_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , end_tangent(Constant<Vector<2, fltp08>>::Invalid)
            , axis_major_point(axis_major_point)
            , radius(Constant<fltp08>::Invalid)
            , angle_start(angle1)
            , angle_end(angle2)
            , axis_ratio(ratio)
            , type(e_elliptic_arc)
            , degree(0)
            , rational(false)
            , periodic(false)
            , is_ccw(ccw)
        {}
 
        HatchEdgeData(uint01 degree, bool rational, bool periodic,
                Buffer<fltp08> knots,
                Buffer<Buffer<fltp08>> controlPoints,
                Buffer<Buffer<fltp08>> fitPoints,
                Buffer<fltp08> weights,
                const Vector<2, fltp08>& start_tangent,
                const Vector<2, fltp08>& end_tangent)
            : control_points(std::move(controlPoints))
            , fit_points(std::move(fitPoints))
            , knots(std::move(knots))
            , weights(std::move(weights))
            , line(Constant<LineSegment<2, fltp08>>::Invalid)
            , center_point(Constant<Vector<2, fltp08>>::Invalid)
            , start_tangent(start_tangent)
            , end_tangent(end_tangent)
            , axis_major_point(Constant<Vector<2, fltp08>>::Invalid)
            , radius(Constant<fltp08>::Invalid)
            , axis_ratio(Constant<fltp08>::Invalid)
            , type(e_spline)
            , degree(degree)
            , rational(rational)
            , periodic(periodic)
            , is_ccw(false)
        {}
        enum EdgeType
        {
              e_undefined = 0
            , e_line = 1
            , e_arc = 2
            , e_elliptic_arc = 3
            , e_spline = 4
        };
        Buffer<Buffer<fltp08>> control_points;
        Buffer<Buffer<fltp08>> fit_points;
        Buffer<Buffer<fltp08>> vertices;
 
        Buffer<fltp08> knots;
        Buffer<fltp08> weights;
 
        LineSegment<2, fltp08> line;
        Vector<2, fltp08> center_point;
        Vector<2, fltp08> start_tangent;
        Vector<2, fltp08> end_tangent;
        Vector<2, fltp08> axis_major_point;
 
        fltp08 radius;
        Angle<fltp08> angle_start;
        Angle<fltp08> angle_end;
        fltp08 axis_ratio;
 
        EdgeType type;
        uint01 degree;
        bool rational;
        bool periodic;
        bool is_ccw;
 
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a viewport in a CAD-friendly way for exporting and importing.
    **/
    struct ViewportData : public EntityData
    {
        uint04 handle = Constant<uint04>::Invalid;
        Vector<2, fltp08> center_point   = Vector<2, fltp08>(0.0);
        Bounds<2, fltp08> screen_bounds  = Bounds<2, fltp08>(0.0, 1.0);
        Vector<2, fltp08> snap_spacing   = Vector<2, fltp08>(0.5);
        Vector<2, fltp08> grid_spacing   = Vector<2, fltp08>(0.5);
        Vector<3, fltp08> view_direction = Vector<3, fltp08>(0.0, 0.0, 1.0);//View Direction FROM target point
        Vector<3, fltp08> target_point   = Vector<3, fltp08>(0.0, 0.0, 0.0);
        fltp08 perspective_lens_length   = 1.0;
        Vector<2, fltp08> clip_planes    = Vector<2, fltp08>(0.0, 1.0);
        fltp08 view_height = 1.0;
        Angle<fltp08> twist_angle    = Angle<fltp08>(0);
        String id = "*Active";
        enum Flags
        {
              e_perspective //1 (0x1) = Enables perspective mode
            , e_enable_front_clipping //2 (0x2) = Enables front clipping
            , e_enable_back_clipping // 4 (0x4) = Enables back clipping
            , e_enable_ucs_follow //8 (0x8) = Enables UCS follow
            , e_enable_front_clip // 16 (0x10) = Enables front clip not at eye
            , e_enable_icon_visible // 32 (0x20) = Enables UCS icon visibility
            , e_enable_ucs_icon_at_origin// 64 (0x40) = Enables UCS icon at origin
            , e_enable_fast_zoom //128 (0x80) = Enables fast zoom
            , e_enable_snaps // 256 (0x100) = Enables snap mode
            , e_enable_grids // 512 (0x200) = Enables grid mode
            , e_enable_iso_snap //1024 (0x400) = Enables isometric snap style
            , e_enable_hide_plot // 2048 (0x800) = Enables hide plot mode
            , e_is_pair_top // 4096 (0x1000) = kIsoPairTop.If set and kIsoPairRight is not set, then isopair top is enabled.If both kIsoPairTop and kIsoPairRight are set, then isopair left is enabled
            , e_iso_pair_right // 8192 (0x2000) = kIsoPairRight.If set and kIsoPairTop is not set, then isopair right is enabled
            , e_enable_viewport_zoom_lock //16384 (0x4000) = Enables viewport zoom locking
            , e_always_enabled // 32768 (0x8000) = Currently always enabled
            , e_enable_non_rect_clipping // 65536 (0x10000) = Enables non - rectangular clipping
            , e_viewport_off // 131072 (0x20000) = Turns the viewport off
            , e_grid_beyond_limits // 262144 (0x40000) = Enables the display of the grid beyond the drawing limits
            , e_adaptive_grid // 524288 (0x80000) = Enable adaptive grid display
            , e_grid_subdivide // 1048576 (0x100000) = Enables subdivision of the grid below the set grid spacing when the grid display is adaptive
            , e_grid_follows_workplane // 2097152 (0x200000) = Enables grid follows workplane switching
        };
        Vector<16, bool> flags = Vector<16, bool>(false);
        enum RenderMode
        {
            e_2D_optimized = 0//2D Optimized(classic 2D)
            , e_wireframe = 1
            , e_hidden_line = 2
            , e_flat_shaded = 3
            , e_gouraud_shaded = 4
            , e_flat_shaded_with_wireframe = 5
            , e_gouraud_shaded_with_wireframe = 6
        };
        enum ViewMode
        {
              e_perspective_view = 0
            , e_front_clipping = 1
            , e_back_clipping = 2
            , e_ucs_follow_mode = 3
            , e_front_clipping_not_at_camera = 4
        };
        bool has_grid = false;
        BitFlag view_mode = BitFlag(0);
        RenderMode render_mode = e_2D_optimized;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a image data in a CAD-friendly way for exporting and importing.
    **/
    struct CADImageData
    {
        CADImageData(const File& iref, Vector<3, fltp08> insertion_point, Vector<3, fltp08> bottom_vector
            , Vector<3, fltp08> left_side, int iwidth, int iheight, uint01 ibrightness = 50, uint01 icontrast = 50, uint01 ifade = 0)
            : ref(iref)
            , insertion_point(insertion_point)
            , bottom_vector(bottom_vector)
            , left_side(left_side)
            , image_size(iwidth, iheight)
            , brightness(ibrightness)
            , contrast(icontrast)
            , fade(ifade)
        {}
 
        File ref;
        Vector<3, fltp08> insertion_point;
        Vector<3, fltp08> bottom_vector;
        Vector<3, fltp08> left_side;
        Vector<2, uint02> image_size;
 
        uint01 brightness; //Brightness (0-100, default = 50).
        uint01 contrast;//Contrast (0-100, default = 50).
        uint01 fade;//Fade (0-100, default = 0)
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief UVOptions used for interfacing with CAD, similar to those used by a Material object.
    **/
    struct MaterialUVOptions
    {
        bool use_value = false;
        fltp08 color_intensity = 1.0;
        RGBColor color = Constant<RGBColor>::Invalid;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Provides CAD information for managing images attached to a Material.
    **/
    struct MaterialUVImageOptions : public MaterialUVOptions
    {
        fltp08 map_blend_factor = 1.0;
        bool use_current_scene = true;
        File map_file;
        RGBColor color = Constant<RGBColor>::Invalid;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A DXF friendly material class which contains UV properties similar to a Material object.
    **/
    struct DXFMaterial : public HandleData
    {
        String name;
        String description;
        MaterialUVOptions ambient;
        MaterialUVImageOptions diffuse;
        MaterialUVImageOptions specular;
        fltp08 specular_gloss_factor = 0.5;
        fltp08 opacity_percent = 1.0;
        Matrix<fltp08> mat_matrix = Matrix<fltp08>(1.0);
 
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A type of entity in CAD representing several entities grouped together.
    **/
    struct DXFGroup : public EntityData
    {
        String name;
        String description;
        bool is_named = false;
        bool selectable = false;
        Buffer<uint04> group_objects;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores the definition of an Image for easy interface with CAD
    **/
    struct ImageDefData
    {
        ImageDefData(const String& iref, const File& ifile)
            : ref(iref)
            , file(ifile)
        {}
        String ref;//Reference to the image file (unique, used to refer to the image def object).
        File file;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief logic for storing a extrusion data in a CAD-friendly way for exporting and importing.
    **/
    class Extrusion
    {
    public:
        Extrusion()
            : m_direction(0)
            , m_elevation(0)
        {}
 
        Extrusion(Vector<3, fltp08> direction, fltp08 elevation)
            : m_direction(direction)
            , m_elevation(elevation)
        {}
 
        void setDirection(fltp08 dx, fltp08 dy, fltp08 dz)
        {
            m_direction[0] = dx;
            m_direction[1] = dy;
            m_direction[2] = dz;
        }
 
        Vector<3, fltp08> getDirection() const { return m_direction; }
        void setElevation(double elevation) { m_elevation = elevation; }
        fltp08 getElevation() const { return m_elevation; }
    private:
        Vector<3, fltp08> m_direction;
        fltp08 m_elevation;
    };
}