EntityConverter.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: EntityConverter
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "CAD/Headers/CADEntityStreamer.h"
#include "CAD/Headers/CADHandleManager.h"
#include "CAD/Headers/DXFValueManager.h"
#include "Design/Headers/DesignObjectLookup.h"
#include "Design/Headers/Geometry.h"
#include "Design/Headers/Model.h"
#include "Design/Headers/ArcShape.h"
#include "Design/Headers/ShapeConstructors.h"
#include "Design/Headers/MeasurementModels.h"
#include "Design/Headers/Text.h"
#include "Base/Headers/MatrixFunctions.h"
#include "Base/Headers/RWLock.h"
#include "Base/Headers/ACIColor.h"
#include "Base/Headers/Translator.h"
#include "Base/Headers/UnitDefinitions.h"
namespace NDEVR
{
    static 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 : public VertexIterator<Vertex<3, fltp04>>
    {
    public:
        CADMeshVertexAttributeSetter(VertexProperty vert_property, const Geometry& geo, const void* lock_ptr)
            : VertexIterator<Vertex<3, fltp04>>(vert_property, geo)
            , lock_ptr(lock_ptr)
        {}
        ~CADMeshVertexAttributeSetter()
        {
            finish();
        }
        void setValue()
        {
            VertexIterator<Vertex<3, fltp04>>::setVertex(current_value++, vertex);
        }
        void finish()
        {
            WLock lock(lock_ptr);
            m_geo.updateVertexColumn(m_vertex_property);
            m_geo.updateModifiedTime();
        }
        Vertex<3, fltp04> vertex = Constant<Vertex<3, fltp04>>::NaN;
        uint04 current_value = 0;
        const void* lock_ptr;
    };
    class CADMeshVertexColorSetter : public VertexIterator<RGBColor>
    {
    public:
        CADMeshVertexColorSetter(VertexProperty vert_property, const Geometry& geo, const void* lock_ptr)
            : VertexIterator<RGBColor>(vert_property, geo)
            , lock_ptr(lock_ptr)
        {}
        ~CADMeshVertexColorSetter()
        {
            finish();
        }
        void setValue()
        {
            VertexIterator<RGBColor>::setVertex(current_value++, vertex);
        }
        void finish()
        {
            WLock lock(lock_ptr);
            m_geo.updateVertexColumn(m_vertex_property);
            m_geo.updateModifiedTime();
        }
        RGBColor vertex = RGBColor(255, 255, 255, 255);
        uint04 current_value = 0;
        const void* lock_ptr;
    };
 
    class EntityConverter : public CADEntityStreamer
    {
    public:
        EntityConverter(const File& relative_path, DesignObjectLookup* lookup, ProgressInfo* logger)
            : CADEntityStreamer(logger)
            , m_core_root(Constant<UUID>::NaN)
            , m_current_paper_root(Constant<UUID>::NaN)
            , m_blocks_root(Constant<UUID>::NaN)
            , m_current_block(Constant<UUID>::NaN)
            , m_current_entity(Constant<UUID>::NaN)
            , m_last_insert(Constant<UUID>::NaN)
            , m_next_bulge(Constant<fltp08>::NaN)
            , m_model_lookup(lookup)
            , m_current_mode(DXFMode::e_none)
            , m_relative_path(relative_path)
        {}
        void setHandleManager(const DynamicPointer<CADHandleManager>& handle_manager)
        {
            m_handle_manager = handle_manager;
        }
        virtual ~EntityConverter() 
        {
            delete m_mesh_attribute_setter;
            delete m_mesh_color_setter;
        }
        /*virtual void processCodeValuePair(unsigned int, const String& s) override
        {
            //int i = s.getAs<int>();
            if(m_log_features) m_logger.addMessage("Code Value Pair");
        }*/
        void setupEntityMaterial(Model model)
        {
            ColorMode mode = m_current_data.color_info.mode;
            if (m_color_by_vertex)
                mode = ColorMode::e_use;
            if (!isNaN(m_current_data.material_handle) && m_current_data.material_handle != 0)
            {
                Material mat = getMaterial();
                model.setMaterial(PrimitiveProperty::Solid, mat);
                model.setMaterial(PrimitiveProperty::Outline, mat);
                model.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_custom);
                model.setMaterialMode(PrimitiveProperty::Outline, Model::MaterialMode::e_custom);
            }
            else
            {
                switch (mode)
                {
                case ColorMode::e_by_layer:
                    model.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_by_layer);
                    break;
                case ColorMode::e_by_block:
                    model.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_by_parent);
                    break;
                case ColorMode::e_background_contrast:
                case ColorMode::e_use:
                {
                    Material mat;
                    if (model.hasMaterial(PrimitiveProperty::Solid))
                        mat = model.getMaterial(PrimitiveProperty::Solid);
                    else
                        mat = getMaterial();
                    if (m_color_by_vertex)
                    {
                        mat.setUVMode(UVType::e_KD, Material::UVMode::e_color_channel);
                        mat.setUVMode(UVType::e_KA, Material::UVMode::e_color_channel);
                    }
                    else if (m_current_data.color_info.mode == ColorMode::e_background_contrast)
                    {
                        mat.setUVMode(UVType::e_KD, Material::UVMode::e_background_contrast);
                        mat.setUVMode(UVType::e_KA, Material::UVMode::e_background_contrast);
                    }
                    else
                    {
                        mat.setUVMode(UVType::e_KD, Material::UVMode::e_color_by_model);
                        mat.setUVMode(UVType::e_KA, Material::UVMode::e_color_by_model);
                    }
                    model.setMaterial(PrimitiveProperty::Solid, mat);
                    model.setMaterial(PrimitiveProperty::Outline, mat);
                    model.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_custom);
                    model.setMaterialMode(PrimitiveProperty::Outline, Model::MaterialMode::e_custom);
 
                } break;
                }
            }
            model.setModelProperty(Model::e_model_color, m_current_data.color_info.color);
 
        }
        void endFaceSection()
        {
            WLock lock = m_model_lookup->writeLock();
            const bool using_tri_mesh = m_quad_position_data.size() == 0;
            Geometry mesh = using_tri_mesh ? currentTriMesh() : currentPolyMesh();
            Vector<3, fltp08> coord_offset(0.0);
            if (mesh.vertexCount() == 0)
            {
                if(m_quad_position_data.size() > 0)
                    coord_offset = m_quad_position_data[0].as<3, fltp08>();
                else if (m_tri_position_data.size() > 0)
                    coord_offset = m_tri_position_data[0].as<3, fltp08>();
                if (distanceSquared(coord_offset, Vector<3, fltp08>(0.0)) > 1000 * 1000)
                {
                    for (uint04 i = 0; i < m_quad_position_data.size(); i++)
                        m_quad_position_data[i] -= coord_offset;
                    for (uint04 i = 0; i < m_tri_position_data.size(); i++)
                        m_tri_position_data[i] -= coord_offset;
                    mesh.offset(coord_offset);
 
                }
            }
            bool using_color = m_quad_color_data.size() > 0 || m_tri_color_data.size() > 0;
            const uint04 quad_index_size = m_quad_position_data.size() / 4;
            const uint04 tri_index_size = m_tri_position_data.size() / 3;
            uint04 index_offset = using_tri_mesh ? mesh.addPrimitives(PrimitiveProperty::Outline, tri_index_size) : mesh.addPrimitives(PrimitiveProperty::Outline, 6 * quad_index_size + 4 * tri_index_size);
            uint04 vertex_offset = mesh.addVertices(m_quad_position_data.size() + m_tri_position_data.size()) + mesh.vertexOffset();
            Geometry::OptimizedPrimitiveDef primitive_setter = mesh.optimizedPrimitiveDef(PrimitiveProperty::Outline);
 
            if (m_quad_position_data.size() > 0)
            {
                mesh.setVertices(VertexProperty::Position, m_quad_position_data);
                if(using_color)
                    mesh.setVertices(VertexProperty::Color, m_quad_color_data);
                for (uint04 i = 0; i < quad_index_size; i++)
                {
                    for (uint04 n = 0; n < 4; n++)
                        Geometry::OptimizedSetPrimitive(primitive_setter, index_offset + 6 * i + n, vertex_offset + 4 * i + n);
 
                    Geometry::OptimizedSetPrimitive(primitive_setter, index_offset + 6 * i + 4U, vertex_offset + 4 * i + 0);
                    Geometry::OptimizedSetPrimitive(primitive_setter, index_offset + 6 * i + 5U, Constant<uint04>::NaN);
                }
                index_offset += quad_index_size * 6;
                vertex_offset += m_quad_position_data.size();
            }
            if (m_tri_position_data.size() > 0)
            {
                mesh.setVertices(VertexProperty::Position, m_tri_position_data, m_quad_position_data.size());
                if(using_color)
                    mesh.setVertices(VertexProperty::Color, m_tri_color_data, m_quad_position_data.size());
                for (uint04 i = 0; i < tri_index_size; i++)
                {
                    if (using_tri_mesh)
                    {
                        Geometry::OptimizedSetPrimitiveVec(primitive_setter, index_offset + i, Vector<3, uint04>(
                              vertex_offset + 3 * i + A
                            , vertex_offset + 3 * i + B
                            , vertex_offset + 3 * i + C));
                    }
                    else
                    {
                        for (uint04 n = 0; n < 3; n++)
                            Geometry::OptimizedSetPrimitive(primitive_setter, index_offset + 4 * i + n, vertex_offset + 3 * i + n);
                        Geometry::OptimizedSetPrimitive(primitive_setter, index_offset + 4 * i + 3U, Constant<uint04>::NaN);
                    }
                }
            }
            m_quad_position_data.clear();
            m_quad_color_data.clear();
            m_tri_position_data.clear();
            m_tri_color_data.clear();
            lib_assert(mesh.validate(), "invalid geometry");
        }
        void endSection() final override 
        {
            switch (m_current_mode)
            {
            case DXFMode::e_3D_trace:
            case DXFMode::e_3D_face:
                endFaceSection();
                break;
            default:
                break;
            }
            
            WLock lock = m_model_lookup->writeLock();
            if (m_mesh_attribute_setter)
            {
                delete m_mesh_attribute_setter;
                m_mesh_attribute_setter = nullptr;
            }
            if (m_mesh_color_setter)
            {
                delete m_mesh_color_setter;
                m_mesh_color_setter = nullptr;
            }
            Geometry geo;
            if (m_current_points.isValid())
            {
                geo = m_current_points;
                m_current_points = Geometry();
            }
            else if (m_current_linework.isValid())
            {
                geo = m_current_linework;
                if (m_current_mode == DXFMode::e_closed_polyline)
                {
                    if (!isNaN(m_next_bulge) && m_next_bulge != 0.0)
                    {
                        uint04 vertex_count = geo.vertexCount();
                        //lib_assert(vertex_count > 1, "Bad vertex count");
                        if (vertex_count > 1)
                        {
                            Vertex<3, fltp08> p1 = geo.vertex<Vertex<3, fltp08>>(VertexProperty::Position, vertex_count - 1);
                            Vertex<3, fltp08> p2 = geo.vertex<Vertex<3, fltp08>>(VertexProperty::Position, 0);
                            addBulge(geo, m_next_bulge, p1, p2);
                        }
                        else
                        {
                            m_logger.addMessage(LogMessage(_t("Unexpected empty closed polyline"),LogMessage::e_warning));
                        }
                        geo.closePolyline(PrimitiveProperty::Outline);
                    }
                    else
                    {
                        geo.closePolyline(PrimitiveProperty::Outline);
                    }
                }
                if (m_current_mode == DXFMode::e_leader)
                {
                    //geo.add
                }
                //lib_assert(currentEntity().globalBounds().span()[Z] < 100.0, "Bad bounds");
                m_current_linework = Geometry();
            }
            
            else if (m_current_mesh.isValid())
            {
                geo = m_current_mesh;
                m_current_mesh = Geometry();
            }
            m_current_geometry = Geometry();
            lib_assert(!m_current_points.isValid(), "Bad valid");
            lib_assert(!m_current_linework.isValid(), "Bad valid");
            lib_assert(!m_current_mesh.isValid(), "Bad valid");
            if (geo.isValid())
            {
                geo.autoCalculateIndices(PrimitiveProperty::Solid);
                geo.updateVertexColumns();
                geo.updatePrimitiveColumns();
                geo.updateModifiedTime();
                lib_assert(geo.validate(), "invalid geometry");
                if (!m_model_lookup->hasGeometryID(geo.uuid()))
                    m_model_lookup->addGeometry(geo);
                currentEntity().invalidateBounds();
                currentEntity().updateModifiedTime();
            }
            m_next_bulge = Constant<fltp08>::NaN;
            m_current_entity = Constant<UUID>::NaN;
            m_current_mode = DXFMode::e_none;
            m_color_by_vertex = false;
            m_position_offset = Constant<Vertex<3, fltp08>>::NaN;
        }
        const ConstPointer<Unit>& unit() const
        {
            return m_unit;
        }
        Material getMaterial()
        {
            if (!isNaN(m_current_data.material_handle) && m_current_data.material_handle != 0)
            {
                return getMaterial(m_current_data.material_handle);
            }
            else
            {
                Material mat = generateNewMaterial();
                
                m_materials_read.add(mat.uuid());
                m_model_lookup->addMaterial(mat);
                return mat;
            }
        }
        void addLayer(const LayerData& layer) final override
        {
            lib_assert(!m_layers.hasKey(layer.name), "Duplicate layer added");
            m_current_data = static_cast<EntityData>(layer);
            _addLayer(layer);
            
        }
        void _addLayer(const LayerData& layer_data)
        {
            if(m_layers.hasKey(layer_data.name))
            {
                m_logger.addMessage(LogMessage(_td("dxf_duplicate_layer", "Unexpected duplicate layer").translation() +": "+ layer_data.name, LogMessage::e_warning));
                return;
            }
            //lib_assert(!m_handle_manager->hasHandleIndex(layer_data.name), "Duplicate layer added");
            if(!isNaN(layer_data.handle))
                m_handle_manager->setHandleIndex(layer_data.name, layer_data.handle);
            
            
            WLock lock = m_model_lookup->writeLock();
            Model layer = getLayer(layer_data.name);
            Material mat;
            if (!layer.hasMaterial(PrimitiveProperty::Solid))
            {
                mat = generateNewMaterial();
                layer.setMaterial(PrimitiveProperty::Solid, mat);
                m_model_lookup->addMaterial(mat);
            }
            else
            {
                mat = layer.getMaterial(PrimitiveProperty::Solid);
            }
            switch (m_current_data.color_info.mode)
            {
            case ColorMode::e_use:
            case ColorMode::e_by_block:
            case ColorMode::e_by_layer:
                mat.setUVMode(UVType::e_KD, Material::UVMode::e_color_by_layer);
                mat.setUVMode(UVType::e_KS, Material::UVMode::e_color_by_layer);
                mat.setUVMode(UVType::e_KA, Material::UVMode::e_color_by_layer);
                mat.setUVColor(m_current_data.color_info.color);
                layer.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_by_layer);
                break;
            case ColorMode::e_background_contrast:
                mat.setUVMode(UVType::e_KD, Material::UVMode::e_background_contrast);
                mat.setUVMode(UVType::e_KS, Material::UVMode::e_background_contrast);
                mat.setUVMode(UVType::e_KA, Material::UVMode::e_background_contrast);
                mat.setUVColor(Constant<RGBColor>::NaN);
                break;
            }
            layer.setModelProperty(Model::e_model_color, m_current_data.color_info.color);
            layer.setMaterial(PrimitiveProperty::Outline, mat);
 
            layer.setProperty(DesignObject::e_is_frozen, layer_data.flags[LayerData::e_locked]);
            //!layer_data.flags[LayerData::e_frozen] && 
            layer.setDesignVisible(layer_data.visible && !layer_data.is_off);
            layer.updateModifiedTime();
            m_layers.add(layer_data.name, layer.uuid());
 
            
        }
        String convertFromCADName(const String& file_name, const TranslatedString& object_type, uint04 object_count)
        {
            String name;
            if (!file_name.beginsWith("__unnamed__"))
                name = file_name;
            if (m_auto_name_objects && name.size() == 0)
            {
                TranslatedString cad_auto_name = _td("cad_auto_name", "[name]-[count]");
                cad_auto_name.replace("[name]", object_type);
                cad_auto_name.replace("[count]", String(object_count + 1));
                name = String(cad_auto_name);
            }
            return name;
        }
        
        void addDictionary(const CADDictionaryObject& dictionary) override
        {
            if (m_mesh_object_dictionary_listeners.hasKey(dictionary.handle))
            {
                UUID geo_id = m_mesh_object_dictionary_listeners.get(dictionary.handle);
                for (const CADVariable& iter : dictionary.data)
                {
                    switch (iter.label.hash())
                    {
                    case String::hash("ADSK_XREC_SUBDVERTEXNORMALS"):
                        m_mesh_object_field_listeners.add(iter.values.last().second.getAs<uint04>(), { geo_id , VertexProperty::Normal});
                        break;
                    case String::hash("ADSK_XREC_SUBDVERTEXTEXCOORDS"):
                        m_mesh_object_field_listeners.add(iter.values.last().second.getAs<uint04>(), { geo_id , VertexProperty::Texture });
                        break;
                    case String::hash("ADSK_XREC_SUBDVERTEXCOLORS"):
                        m_mesh_object_color_listeners.add(iter.values.last().second.getAs<uint04>(), { geo_id , VertexProperty::Color });
                        break;
                    }
                }
            }
        }
        
        void addXRecord(const HandleData& record) override
        {
            if (m_ignore_current)
                return;
            if (m_mesh_object_field_listeners.hasKey(record.handle))
            {
                Geometry geo = m_model_lookup->geometry(m_mesh_object_field_listeners.get(record.handle).first);
                VertexProperty vert_property = m_mesh_object_field_listeners.get(record.handle).second;
                delete m_mesh_attribute_setter;
                geo.setVertexMode(vert_property, Geometry::VertexMode::e_cartesian_3F);
                m_mesh_attribute_setter = new CADMeshVertexAttributeSetter(vert_property, geo, m_model_lookup->lockPtr());
                m_xdata_callback = [this](uint04 value, DXFValueManager* value_manager)
                {
                    switch (value)
                    {
                    case 40: m_mesh_attribute_setter->vertex[X] = value_manager->getValue<40>(0.0f); break;
                    case 41: m_mesh_attribute_setter->vertex[Y] = value_manager->getValue<41>(0.0f); break;
                    case 42: m_mesh_attribute_setter->vertex[Z] = value_manager->getValue<42>(0.0f);
                        m_mesh_attribute_setter->setValue();
                        break;
                    case 43: m_mesh_attribute_setter->vertex[X] = value_manager->getValue<43>(0.0f); break;
                    case 44: m_mesh_attribute_setter->vertex[Y] = value_manager->getValue<44>(0.0f); break;
                    case 45: m_mesh_attribute_setter->vertex[Z] = value_manager->getValue<45>(0.0f);
                        m_mesh_attribute_setter->setValue();
                        break;
                    }
                };
            } 
            else if (m_mesh_object_color_listeners.hasKey(record.handle))
            {
                Geometry geo = m_model_lookup->geometry(m_mesh_object_color_listeners.get(record.handle).first);
                VertexProperty vert_property = m_mesh_object_color_listeners.get(record.handle).second;
                delete m_mesh_color_setter;
                geo.setVertexMode(vert_property, Geometry::VertexMode::e_color_rgb);
                m_mesh_color_setter = new CADMeshVertexColorSetter(vert_property, geo, m_model_lookup->lockPtr());
                
 
                m_xdata_callback = [this](uint04 value, DXFValueManager* value_manager)
                {
                    switch (value)
                    {
                    case 70: m_mesh_color_setter->vertex[RGBColor::r_pos] = value_manager->getValue<70>(0U); break;
                    case 71: m_mesh_color_setter->vertex[RGBColor::g_pos] = value_manager->getValue<71>(0U); break;
                    case 72: m_mesh_color_setter->vertex[RGBColor::b_pos] = value_manager->getValue<72>(0U);
                        m_mesh_color_setter->setValue();
                        break;
                    }
                };
                WLock lock = m_model_lookup->writeLock();
                Buffer<Model> parents = geo.getParents();
                for (Model& model : parents)
                {
                    
                    Material solid_material = model.hasMaterial(PrimitiveProperty::Solid)
                        ? model.getMaterial(PrimitiveProperty::Solid) : model.createChildMaterial(PrimitiveProperty::Solid);
                    solid_material.setUVMode(UVType::e_KD, Material::UVMode::e_color_channel);
                    solid_material.setUVMode(UVType::e_KA, Material::UVMode::e_color_channel);
                    solid_material.updateModifiedTime();
 
                    if (model.hasMaterial(PrimitiveProperty::Outline))
                    {
                        Material outine_material = model.getMaterial(PrimitiveProperty::Outline);
 
                        outine_material.setUVMode(UVType::e_KD, Material::UVMode::e_color_channel);
                        outine_material.setUVMode(UVType::e_KA, Material::UVMode::e_color_channel);
                        outine_material.updateModifiedTime();
                    }
                    else
                    {
                        model.setMaterial(PrimitiveProperty::Outline, solid_material);
                    }
                    model.setMaterialMode(PrimitiveProperty::Solid, Model::MaterialMode::e_custom);
                    model.setMaterialMode(PrimitiveProperty::Outline, Model::MaterialMode::e_custom);
                    model.updateModifiedTime();
                }
            }
            else
            {
                m_xdata_callback = nullptr;
            }
        }
        void addXRecordData(uint04 value, DXFValueManager* value_manager) override
        {
            if (m_xdata_callback != nullptr)
            {
                m_xdata_callback(value, value_manager);
            }
            else
            {
                if (value == 1001)
                {
                    m_last_x_data_label = value_manager->getValue(value, m_last_x_data_label);
                    value_manager->setValue(value, String());
                }
                else
                {
                    //lib_assert(m_last_x_data_label.size() > 0, "Unexpected X Data Missing");
                    if (m_last_x_data_label.size() > 0)
                    {
                        m_x_data[m_last_x_data_label] = value_manager->getValue(value, String());
                        value_manager->setValue(value, String());
                        m_last_x_data_label.clear();
                    }
                }
            }
 
        };
        void addDXFMaterial(DXFMaterial& mat) override
        {
            if (m_ignore_known_materials)
            {
                UUID uuid = m_handle_manager->getHandleUUID(mat.handle);
                if (Material material = m_model_lookup->material(uuid))
                {
                    m_materials.add(mat.handle, material);
                    return;
                }
            }
            Material material = getMaterial(mat.handle);
 
            
 
            material.setProperty(DesignObject::e_name, convertFromCADName(mat.name, _t("Material"), m_materials.size()));
            material.setProperty(DesignObject::e_description, mat.description);
 
            if(!isNaN(mat.ambient.color))
                material.setUVColor(UVType::e_KA, mat.ambient.color);
            material.setUVIntensity(UVType::e_KA, mat.ambient.color_intensity);
            if (!isNaN(mat.diffuse.color))
                material.setUVColor(UVType::e_KD, mat.diffuse.color);
            material.setUVIntensity(UVType::e_KD, mat.diffuse.color_intensity);
            File diffuse_map_file = mat.diffuse.map_file;
            diffuse_map_file.replace(".\\", m_relative_path);
            diffuse_map_file.replace("./", m_relative_path);
            material.setUVImage(UVType::e_KD, diffuse_map_file);
            if (diffuse_map_file.exists())
                material.setUVMode(UVType::e_KD, Material::UVMode::e_image);
            //else
                //material.setUVMode(UVType::e_KD, Material::UVMode::e_solid_color);
            material.setProperty(DesignObject::e_transform, mat.mat_matrix);
            material.setUVColor(UVType::e_KS, mat.specular.color);
            material.setUVIntensity(UVType::e_KS, mat.specular.color_intensity);
 
            File specular_map_file = mat.diffuse.map_file;
            specular_map_file.replace(".\\", m_relative_path);
            specular_map_file.replace("./", m_relative_path);
            material.setUVImage(UVType::e_KS, specular_map_file);
            if (specular_map_file.exists())
                material.setUVMode(UVType::e_KS, Material::UVMode::e_image);
            //else
                //material.setUVMode(UVType::e_KS, Material::UVMode::e_solid_color);
            material.setMaterialProperty(Material::e_shininess, mat.specular_gloss_factor);
            material.setShadingModel(Material::ShadingModel::e_gouraud);
            material.updateModifiedTime();
            m_materials.add(mat.handle, material);
            
        }
        Model getLayer(const String& layer_name)
        {
            Model layer;
 
            if (m_layers.hasKey(layer_name))
            {
                return m_model_lookup->layer(m_layers.get(layer_name));
            }
            String actual_name = convertFromCADName(layer_name, _t("Layer"), m_layers.size());
            Model layer_ptr = m_model_lookup->findLayer(actual_name);
            if (layer_ptr.isValid())
            {
                m_layers.insert({ layer_name, layer_ptr.uuid() });
                return layer_ptr;
            }
            else
            {
                UUID uuid = UUID::CreateUUID(layer_name);
                if (!m_model_lookup->hasLayerID(uuid))
                {
                    layer = currentRoot().createSceneLayer();
                    layer.setProperty(DesignObject::e_name, actual_name);
                    layer.setProperty(DesignObject::e_guid, uuid);
                    m_model_lookup->addLayer(layer);
                    m_layers.insert({ layer_name, layer.uuid() });
                }
                else
                {
                    layer = m_model_lookup->layer(uuid);
                    layer.updateProperty(DesignObject::e_is_deleted, false, m_model_lookup->lockPtr());
                }
            }
            return layer;
        }
        Material generateNewMaterial()
        {
            Material material = currentRoot().createSceneMaterial();
            material.setUVMode(UVType::e_KD, Material::UVMode::e_color_by_layer);
            material.setUVMode(UVType::e_KA, Material::UVMode::e_color_by_layer);
            material.setMaterialProperty(Material::e_two_sided, true);
            return material;
        }
        Material getMaterial(const uint04& material_handle)
        {
            UUID uuid = m_handle_manager->getHandleUUID(material_handle);
            Material material = m_model_lookup->material(uuid);
            if (!material.isValid())
            {
                WLock lock = m_model_lookup->writeLock();
                lib_assert(!m_model_lookup->hasLayerID(uuid), "added layer?");
                lib_assert(!m_model_lookup->hasModelID(uuid), "added model?");
                lib_assert(!m_model_lookup->hasGeometryID(uuid), "added geometry?");
                lib_assert(!m_model_lookup->hasMaterialID(uuid), "added material?");
 
                material = generateNewMaterial();
                lib_assert(!m_model_lookup->hasMaterialID(uuid), "added material?");
                material.setProperty(DesignObject::e_guid, uuid);
 
                
 
                m_model_lookup->addMaterial(material);
                m_materials_read.add(uuid);
            }
            return material;
        }
        virtual void addLinetype(const LineTypeData&) override { if (m_log_features) m_logger.addMessage(_t("Add Line Type")); }
        virtual void addLinetypeDash(double) override { if (m_log_features) m_logger.addMessage(_t("Add Line Type Dash")); }
 
        Model getBlockModel(const String& block_name)
        {
            if (m_blocks.hasKey(block_name))
            {
                return m_model_lookup->model(m_blocks.get(block_name));
            }
            UUID uuid = UUID::CreateUUID();
            if (m_handle_manager->hasHandleIndex(block_name))
            {
                uint04 handle = m_handle_manager->getHandleIndex(block_name);
                uuid = m_handle_manager->getHandleUUID(handle);
                lib_assert(!m_model_lookup->hasMaterialID(uuid), "added material?");
                lib_assert(!m_model_lookup->hasGeometryID(uuid), "added geometry?");
                lib_assert(!m_model_lookup->hasLayerID(uuid), "added layer?");
                if (Model block = m_model_lookup->model(uuid))
                {
                    block.updateTransform(Matrix<fltp08>(1.0));
                    //if (!block.hasParent())
                        //m_model_roots.add(block.uuid());
                    return block;
                }
            }
            Model block_group;
            if (isNaN(m_blocks_root))
            {
                if (m_group_import)
                {
                    block_group = currentRoot().createChild();
                }
                else
                {
                    block_group = currentRoot().createSceneModel();
                    m_model_roots.add(block_group.uuid());
                }
                block_group.setDesignVisible(false);
                block_group.setProperty(DesignObject::e_name, _td("dxf_blocks_container_name", "Blocks"));
                block_group.setProperty(DesignObject::e_icon, "database");
                block_group.setProperty(DesignObject::e_bounds_ignored, true);
                block_group.setProperty(DesignObject::e_is_application_owned, true);
                block_group.setProperty(DesignObject::e_tree_visible, false);
                block_group.setModelProperty(Model::e_export_ignored, true);
                m_blocks_root = block_group.uuid();
                m_model_lookup->addModel(block_group);
            }
            else
            {
                block_group = m_model_lookup->model(m_blocks_root);
            }
            Model block = block_group.createChild();
            block.setProperty(DesignObject::e_guid, uuid);
            m_blocks_read.add(uuid);
            m_model_lookup->addModel(block);
            return block;
        }
        void copyBlock(Model& model, Model& block)
        {
            Matrix<fltp08> transform = model.getTransform();
            
            if (model != block)
            {
                uint04 layer_index = model.getDirectLayerIndex();
                model.copyFrom(block, block.getScene() != model.getScene(), false);
                if (!isNaN(layer_index))
                    model.setLayer(Model(layer_index, &model.base()));
                else
                    model.clearLayer();
            }
            model.setTransform(transform);
            Buffer<Model> block_children = block.getChildren();
            Buffer<Model> model_children = model.getChildren();
            for (uint04 i = 0; i < block_children.size(); i++)
            {
                if (m_child_blocks_to_insert.hasKey(block_children[i].uuid()))
                {
                    String block_layer = m_child_blocks_to_insert.get(block_children[i].uuid());
                    if (m_handle_manager->hasHandleIndex(block_layer))
                    {
                        Model block = getBlockModel(block_layer);
                        copyBlock(model_children[i], block);
                    }
                    else
                    {
                        m_blocks_to_insert[block_layer].add(model_children[i]);
                    }
                    m_child_blocks_to_insert.erase(block_children[i].uuid());
                }
            }
        }
        virtual void addGroup(const DXFGroup& group_info) override 
        {
            m_current_data = group_info;
            Model model = currentEntity();
            model.setDesignVisible(group_info.visible);
            model.setProperty(DesignObject::e_name, convertFromCADName(group_info.name, _t("Block"), m_blocks_read.size()));
            model.setProperty(DesignObject::e_description, group_info.description);
            for (uint04 i = 0; i < group_info.group_objects.size(); i++)
            {
                UUID uuid = m_handle_manager->getHandleUUID(group_info.group_objects[i]);
                Model child_model = m_model_lookup->model(uuid);
                if (child_model.isValid())
                {
                    model.addChild(child_model);
                    child_model.updateModifiedTime();
                }
 
            }
            model.updateModifiedTime();
        }
        virtual void addBlock(const BlockData& block_info)  override
        {
            endSection();
            m_current_data = static_cast<EntityData>(block_info);
            WLock lock = m_model_lookup->writeLock();
            
            lib_assert(m_current_block_name.size() == 0, "Cannot have nested blocks");
            m_current_block_name = block_info.name;
            //if (block_info.name == "*Model_Space" || block_info.name == "*Paper_Space")
                //return;
            if (m_ignore_known_blocks && m_handle_manager->hasHandleIndex(block_info.name))
            {
                uint04 handle = m_handle_manager->getHandleIndex(block_info.name);
                m_current_block = m_handle_manager->getHandleUUID(handle);
                if (m_model_lookup->hasModelID(m_current_block))
                {
                    m_ignore_current = true;//will allow us to ingore any info in this block
                    return;
                }
            }
            if (!isNaN(block_info.handle) && !m_handle_manager->hasHandleIndex(block_info.name))
                m_handle_manager->setHandleIndex(block_info.name, block_info.handle);
            Model block = getBlockModel(block_info.name);
            
            block.setDesignVisible(block_info.visible);
            block.setProperty(DesignObject::e_name, convertFromCADName(block_info.name, _t("Block"), m_blocks_read.size()));
            block.setProperty(DesignObject::e_description, block_info.description);
            
            setupEntityMaterial(block);
            Matrix<fltp08> trans(1.0);
            trans = trans.offset(block_info.offset);
            block.updateTransform(trans);
            
            m_current_block = block.uuid();
            m_handle_manager->setHandleIndex(m_current_block, block_info.handle);
 
        }
        virtual void endBlock(const uint04&) override
        {
            endSection();
            
            if (m_current_block_name.size() > 0)
            {
                /*if (m_current_block_name == "*Model_Space" || m_current_block_name == "*Paper_Space")
                {
                    m_current_block_name.clear();
                    return;
                }*/
                if (m_ignore_current)
                    m_ignore_current = false;
                m_blocks.insert({ m_current_block_name, m_current_block });
                Model block = getBlockModel(m_current_block_name);
                if (m_blocks_to_insert.hasKey(m_current_block_name))
                {
                    WLock lock = m_model_lookup->writeLock();
                    for (Model& model : m_blocks_to_insert[m_current_block_name])
                        copyBlock(model, block);
                    m_blocks_to_insert.erase(m_current_block_name);
                }
                m_current_block_name.clear();
                m_current_block = Constant<UUID>::NaN;
                m_last_insert = Constant<UUID>::NaN;
            }
            else
            {
                lib_assert(false, "invalid dxf");
                m_logger.addMessage(LogMessage(_t("Unexpected End Block"), LogMessage::e_warning));
            }
 
        }
        void setupColorForGeoVertices()
        {
            if (m_color_by_vertex)
                return;
            m_color_by_vertex = true;
            
            if (m_current_geometry.isValid())
            {
                WLock lock = m_model_lookup->writeLock();
                m_current_geometry.setVertexMode(VertexProperty::Color, Geometry::VertexMode::e_color_rgb);
                uint04 vertex_count = m_current_geometry.vertexCount();
                for (uint04 i = 0; i < vertex_count; i++)
                {
                    m_current_geometry.setVertex(VertexProperty::Color, i, m_current_data.color_info.color);
                }
            }
            if (!isNaN(m_current_entity))
            {
                WLock lock = m_model_lookup->writeLock();
                setupEntityMaterial(m_model_lookup->model(m_current_entity));
            }
            m_quad_color_data = Buffer<RGBColor>(m_quad_position_data.size(), m_current_data.color_info.color);
            m_tri_color_data = Buffer<RGBColor>(m_tri_color_data.size(), m_current_data.color_info.color);
            
        }
        virtual void addTextStyle(const StyleData& text_style) override
        { 
            m_text_styles.insert({ text_style.name, text_style });
        }
        virtual void addPoint(const PointData& point) override
        {
            if (m_ignore_current)
                return;
            if (isNaN(point.location))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Point").translation() + ": " + String(point.file_line_number), LogMessage::e_warning));
                return;
            }
            WLock lock = m_model_lookup->writeLock();
            if (!m_current_points.isValid())
            {
                endSection();
                m_current_data = point;
            }
            else if(m_current_data.color_info != point.color_info)
            {
                setupColorForGeoVertices();
            }
            Geometry cloud_geo = currentCloud();
            if (isNaN(m_position_offset))
            {
                if (cloud_geo.vertexCount() == 0)
                {
                    m_position_offset = point.location;
                    cloud_geo.offset(m_position_offset);
                }
                else
                {
                    m_position_offset = cloud_geo.getTransform().decomposeOffset();
                }
            }
            uint04 index = cloud_geo.addVertex();
            cloud_geo.setVertex(VertexProperty::Position, index, point.location - m_position_offset);
            if (m_color_by_vertex)
                cloud_geo.setVertex(VertexProperty::Color, index, point.color_info.color);
 
            /*Matrix<fltp08> mat = GetOrientation(point.extrusion);
            mat = mat.rotate(point.effect_angle, Vector<3, fltp08>(0, 0, 1));
            mat = mat.offset(offset);
            cloud_geo.setTransform(mat);*/
            m_x_data.clear();
        }
        void addLine(const LineData& line) override
        {
            if (m_ignore_current)
                return;
            if (isNaN(line.line))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Line").translation() + ": " + String(line.file_line_number), LogMessage::e_warning));
                return;
            }
            if (!m_current_linework.isValid() || m_current_mode != e_line)
            {
                endSection();
                m_current_mode = e_line;
                m_current_data = line;
            }
            else if (m_current_data.color_info != line.color_info)
            {
                setupColorForGeoVertices();
            }
            WLock lock = m_model_lookup->writeLock();
            currentLinework().setGeometryProperty(Geometry::e_shape_type, "line");
            if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                currentEntity().setProperty(DesignObject::e_icon, "line");
            
            //Matrix<fltp08> trans(1.0);// = GetOrientation(line.extrusion);
            //currentLinework().setTransform(trans);
        
            Geometry line_geo = currentLinework();
            if (isNaN(m_position_offset))
            {
                if (line_geo.vertexCount() == 0)
                {
                    m_position_offset = line.line[A];
                    line_geo.offset(m_position_offset);
                }
                else
                {
                    m_position_offset = line_geo.getTransform().decomposeOffset();
                }
            }
            uint04 index = line_geo.addVertices(2);
            if (line.thickness > 0)
            {
                line_geo.setThicknessMode(Geometry::ThicknessMode::e_flat_single);
                line_geo.setGeometryProperty(Geometry::e_thickness, line.thickness);
            }
            if(index == 0)
                line_geo.setPrimitiveMode(PrimitiveProperty::Outline, PrimitiveMode::e_lines);
            else
                lib_assert(line_geo.mode(PrimitiveProperty::Outline) == PrimitiveMode::e_lines, "Bad line object");
            line_geo.setVertex(VertexProperty::Position, index + A, line.line[A] - m_position_offset);
            line_geo.setVertex(VertexProperty::Position, index + B, line.line[B] - m_position_offset);
            if (m_color_by_vertex)
            {
                line_geo.setVertex(VertexProperty::Color, index + A, line.color_info.color);
                line_geo.setVertex(VertexProperty::Color, index + B, line.color_info.color);
            }
            line_geo.addPrimitive(PrimitiveProperty::Outline, Vector<2, uint04>(index + A, index + B));
            m_x_data.clear();
        }
        void addXLine(const LineData& line) override
        {
            if (m_ignore_current)
                return;
            endSection();
            if (isNaN(line.line))
            {
                m_logger.addMessage(LogMessage(_t("Invalid XLine").translation() + ": " + String(line.file_line_number), LogMessage::e_warning));
                return;
            }
            m_current_mode = e_line;
            WLock lock = m_model_lookup->writeLock();
            Geometry geo = currentLinework();
            if (isNaN(m_position_offset))
            {
                if (geo.vertexCount() == 0)
                {
                    m_position_offset = line.line[A];
                    geo.offset(m_position_offset);
                }
                else
                {
                    m_position_offset = geo.getTransform().decomposeOffset();
                }
            }
            geo.setProperty(DesignObject::e_bounds_ignored, true);
            uint04 index = geo.addVertices(2);
            if (index == 0)
                geo.setPrimitiveMode(PrimitiveProperty::Outline, PrimitiveMode::e_lines);
            else
                lib_assert(geo.mode(PrimitiveProperty::Outline) == PrimitiveMode::e_lines, "Bad line object");
            geo.setVertex(VertexProperty::Position, index + A, line.line[A] - m_position_offset);
            geo.setVertex(VertexProperty::Position, index + B, line.line[B] - m_position_offset);
            if (m_color_by_vertex)
            {
                geo.setVertex(VertexProperty::Color, index + A, line.color_info.color);
                geo.setVertex(VertexProperty::Color, index + B, line.color_info.color);
            }
            geo.addPrimitive(PrimitiveProperty::Outline, Vector<2, uint04>(index + A, index + B));
            m_x_data.clear();
        }
        void addRay(const LineData& ray) override
        {
            if (m_ignore_current)
                return;
            endSection();
            if (isNaN(ray.line))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Ray").translation() + ": " + String(ray.file_line_number), LogMessage::e_warning));
                return;
            }
            m_current_mode = e_line;
            WLock lock = m_model_lookup->writeLock();
            Geometry geo = currentLinework();
            if (isNaN(m_position_offset))
            {
                if (geo.vertexCount() == 0)
                {
                    m_position_offset = ray.line[A];
                    geo.offset(m_position_offset);
                }
                else
                {
                    m_position_offset = geo.getTransform().decomposeOffset();
                }
            }
            uint04 index = geo.addVertices(2);
            geo.setVertex(VertexProperty::Position, index + A, ray.line[A] - m_position_offset);
            geo.setVertex(VertexProperty::Position, index + B, ray.line[B] - m_position_offset);
            geo.addPrimitive(PrimitiveProperty::Outline, Vector<2, uint04>(index + A, index + B));
        }
 
        virtual void addTrace(const TraceData& data) override
        {
            if (m_ignore_current)
                return;
            if (isNaN(data.points[A]))
            {
                m_logger.addMessage(LogMessage(_t("Invalid TraceData").translation() + ": " + String(data.file_line_number), LogMessage::e_warning));
            }
            if (m_current_mode != DXFMode::e_3D_trace)
            {
                endSection();
                m_current_data = data;
                m_current_mode = DXFMode::e_3D_trace;
            }
            else
            {
                if (m_current_data.color_info != data.color_info)
                    setupColorForGeoVertices();
            }
            m_current_data = data;
            //mesh.setGeometryProperty(Geometry::e_thickness, data.thickness);
            
            Matrix<fltp08> mat = GetOrientation(data.extrusion).invert();
            for(uint04 i = 0; i < 4; i++)
                m_quad_position_data.add(mat * data.points[i]);
            if (m_color_by_vertex)
                m_quad_color_data.add(data.color_info.color);
        }
        virtual void add3dFace(const TraceData& data) override
        {
            if (m_ignore_current)
                return;
            if (isNaN(data.points[A]))
            {
                m_logger.addMessage(LogMessage(_t("Invalid 3DFace").translation() + ": " + String(data.file_line_number), LogMessage::e_warning));
            }
            if (m_current_mode != DXFMode::e_3D_face)
            {
                endSection();
                m_current_data = data;
                m_current_mode = DXFMode::e_3D_face;
            }
            else
            {
                if (m_current_data.color_info != data.color_info)
                    setupColorForGeoVertices();
            }
            Vertex<3, fltp08> points[4];
            memmove(points, data.points, sizeof(data.points));
            bool has_duplicate = false;
            if (points[C] == points[D])
            {
                has_duplicate = true;
            }
            else if (points[D] == points[A])
            {
                has_duplicate = true;
            }
            else if (points[A] == points[B])
            {
                has_duplicate = true;
                std::swap(points[A], points[D]);
            }
            else if (points[B] == points[C])
            {
                has_duplicate = true;
                std::swap(points[C], points[D]);
            }
            uint04 num_of_sides = has_duplicate ? 3 : 4;
            if (num_of_sides == 4)
            {
                LineSegment<3, fltp08> a(data.points[A], data.points[B]);
                LineSegment<3, fltp08> b(data.points[B], data.points[C]);
                LineSegment<3, fltp08> c(data.points[C], data.points[D]);
                LineSegment<3, fltp08> e(data.points[D], data.points[A]);
                if (a.intersects<fltp08>(c) || b.intersects<fltp08>(e))
                {
                    for (uint04 i = 0; i < 2; i++)
                        m_quad_position_data.add(data.points[i]);
                    m_quad_position_data.add(data.points[D]);
                    m_quad_position_data.add(data.points[C]);
                    
                }
                else
                {
                    for (uint04 i = 0; i < 4; i++)
                        m_quad_position_data.add(data.points[i]);
                }
                if (m_color_by_vertex)
                {
                    for(uint04 i = 0; i < 4; i++)
                        m_quad_color_data.add(data.color_info.color);
                }
            }
            else
            {
                for (uint04 i = 0; i < 3; i++)
                    m_tri_position_data.add(points[i]);
                if (m_color_by_vertex)
                {
                    for (uint04 i = 0; i < 3; i++)
                        m_tri_color_data.add(data.color_info.color);
                }
            }
        }
 
        void addArc(const ArcData& arc) override
        {
            if (m_ignore_current)
                return;
            endSection();
            if (isNaN(arc.angle1) || isNaN(arc.angle2) || isNaN(arc.radius))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Arc").translation() + ": " + String(arc.file_line_number), LogMessage::e_warning));
                return;
            }
            WLock lock = m_model_lookup->writeLock();
            m_current_data = arc;
            m_current_mode = e_polyline;
            Model model = currentEntity();
            
            //m_current_linework = model.uuid();
            //Geometry geo = model.createChildGeometry();
            //geo.setGeometryProperty(Geometry::e_thickness, arc.thickness);
            
            ArcShape arc_shape(model);
            arc_shape.setupConicArc(arc.angle1, arc.angle2, arc.radius);
            Matrix<fltp08> trans = GetOrientation(arc.extrusion).invert();
            trans = trans.offset(arc.offset);
            //trans = trans.scale(Vector<3, fltp08>(-1.0, 1.0, 1.0));
            model.setTransform(trans);
 
        }
#if NDEVR_TEXT_MODEL
        void addAttribute(const Attrib& attribute) override
        {
            if (m_ignore_current)
                return;
            endSection();
            Attrib new_attribute(attribute);
            new_attribute.text = attribute.default_value;
            Text text;
            if (m_model_lookup->hasModelID(m_last_insert))
            {
                UUID old_block = m_current_block;
                m_current_block = m_last_insert;
                Buffer<Model> children = currentBlock().getChildrenByName(attribute.tag);
                if (children.size() > 0)
                {
                    text = children.last();
                    setupTextData(text, new_attribute);
                }
                else
                {
                    
                    text = createFromTextData(new_attribute);
                }
                
                text.setTransform(m_model_lookup->model(m_last_insert).getCompleteTransform().invert()* text.getTransform());
                text.setProperty(DesignObject::e_name, convertFromCADName(attribute.tag, _t("Attribute"), Constant<uint04>::NaN));
                m_current_block = old_block;
            }
            else
            {
                text = createFromTextData(new_attribute);
                text.setProperty(DesignObject::e_name, convertFromCADName(attribute.tag, _t("Attribute"), m_attribute_count++));
            }
            setupEntityMaterial(text);
            if (text.getProperty<String>(DesignObject::e_icon).size() == 0)
                text.setProperty(DesignObject::e_icon, "label");
            endSection();
        }
        void addAttributeDefintion(const Attrib& attribute) override
        {
            Attrib new_attribute(attribute);
            new_attribute.text = attribute.default_value;
            //addText(new_attribute);
        }
        Text createFromTextData(const TextData& data)
        {
 
            TextData tex_data = data;
            m_current_data = data;
            DynamicPointer<TextConstructor> constructor;
            if (m_text_styles.hasKey(data.style))
            {
                const StyleData& style = m_text_styles.get(data.style);
                Font font;
                font.name = style.primary_font_file;
                constructor = getTextContructor(style.primary_font_file, font);
                if (!isNaN(style.width_factor) && style.width_factor != 0.0)
                    tex_data.reference_width *= style.width_factor;
                if (isNaN(tex_data.height) && !isNaN(style.fixed_text_height) && style.fixed_text_height != 0.0)
                    tex_data.height = style.fixed_text_height;
            }
            if (constructor.isNull())
                constructor = getTextContructor(FontEngine::DefaultFont);
            WLock lock = m_model_lookup->writeLock();
            Text text(currentEntity(), constructor);
            setupTextData(text, tex_data);
            return text;
        }
 
        virtual void addText(const TextData& data) override
        {
            if (m_ignore_current)
                return;
            endSection();
            createFromTextData(data);
            m_x_data.clear();
            endSection();
        }
#endif
        void addCircle(const CircleData& c) override
        {
            if (m_ignore_current)
                return;
            endSection();
            if (isNaN(c.circle.center()) || isNaN(c.circle.radius()))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Circle").translation() + ": " + String(c.file_line_number), LogMessage::e_warning));
                return;
            }
            WLock lock = m_model_lookup->writeLock();
            m_current_data = c;
            m_current_mode = e_polyline;
            Model model = currentEntity();
            if (model.getProperty<String>(DesignObject::e_icon).size() == 0)
                model.setProperty(DesignObject::e_icon, "circle");
            if (model.getProperty<String>(DesignObject::e_name).size() == 0)
                model.setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Circle"), m_circle_count++));
            m_current_linework = model.createChildGeometry();
            m_current_linework.setGeometryProperty(Geometry::e_thickness, c.thickness);
            m_current_linework.setGeometryType(GeometryType::e_linework);
            m_current_linework.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            ShapeConstructors::Circle(m_current_linework);
            m_current_linework.autoCalculateIndices(PrimitiveProperty::Solid, nullptr);
            m_current_linework.updateModifiedTime();
            Matrix<fltp08> trans = GetOrientation(c.extrusion).invert();
            trans = trans.offset(c.circle.center());
            trans = trans.scale(c.circle.radius());
            if (m_current_data.paper_space)
            {
                trans = m_current_data.paper_space_info.paperToModelMatrix() * trans;
            }
            model.setTransform(trans);
            model.updateModifiedTime();
        }
        virtual void addEllipse(const EllipseData& e) override 
        {
            if (m_ignore_current)
                return;
            /*if (isNaN(e.ellipse.axisPoint(A)) || isNaN(e.ellipse.axisPoint(B)) || isNaN(e.ellipse.radius()))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Circle") + ": " + String(e.file_line_number), LogMessage::e_warning));
                return;
            }*/
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = e;
            m_current_mode = e_polyline;
            Model model = currentEntity();
            if (model.getProperty<String>(DesignObject::e_icon).size() == 0)
                model.setProperty(DesignObject::e_icon, "oval");
            m_current_linework = model.createChildGeometry();
            m_current_linework.setGeometryType(GeometryType::e_linework);
            m_current_linework.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            m_current_linework.setGeometryProperty(Geometry::e_thickness, e.thickness);
            Angle<fltp08> start = e.angle1;
            Angle<fltp08> end = e.angle2;
            Matrix<fltp08> trans = GetOrientation(e.extrusion).invert();
 
            Vertex<3, fltp08> major_axis_endpoint = trans.invert() * e.endpoint_of_major_axis;
 
            const Vector<3, fltp08> center_point(e.center);
            fltp08 ratio = e.minor_to_major_ratio;
            fltp08 radius = ratio * major_axis_endpoint.magnitude<fltp08>();
            Vector<3, fltp08> dt = major_axis_endpoint - (ratio * major_axis_endpoint);
            Vector<3, fltp08> p1 = center_point - dt;
            Vector<3, fltp08> p2 = center_point + dt;
            BiRadialObject<3, fltp08> radial(p1, p2, radius);
            Vector<3, fltp08> axis = major_axis_endpoint.normalized<fltp08>();
            Angle<fltp08> offset_angle = AngleDefinitions::Heading<fltp08>(axis);
 
            start += offset_angle;
            end += offset_angle;
 
 
            if (end < start)
                end += Angle<fltp08>(DEGREES, 360.0);
            Angle<fltp08> phi = end - start;
            if (phi > Angle<fltp08>(DEGREES, 360.0))
                phi = Angle<fltp08>(DEGREES, 360.0);
            ShapeConstructors::Circle(m_current_linework, Matrix<fltp08>(1.0), 44, 1.0, start, phi, false);
            m_current_linework.autoCalculateIndices(PrimitiveProperty::Solid, nullptr);
            m_current_linework.updateModifiedTime();
 
            BiRadialObject<3, fltp08> radial_obj(p1, p2, radius);
            trans *= trans.offset(radial_obj.center());
            trans *= radial_obj.fromCircleTransform();
            if(e.extrusion[Z] < 0)
                trans = trans.scale(Vector<3, fltp08>(-1.0, 1.0, 1.0));
            if (m_current_data.paper_space)
            {
                trans = m_current_data.paper_space_info.paperToModelMatrix() * trans;
            }
            model.setTransform(trans);
            if (model.getProperty<String>(DesignObject::e_name).size() == 0)
                model.setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Ellipse"), m_ellipse_count++));
            model.updateModifiedTime();
        }
        virtual void addPolyline(const PolylineData& poly) override
        {
            if (m_ignore_current)
                return;
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = poly;
            Geometry geo;
            if (poly.flags[PolylineData::e_closed] || poly.flags[PolylineData::e_is_3D_polygon])
            {
                m_current_mode = DXFMode::e_closed_polyline;
                if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                    currentEntity().setProperty(DesignObject::e_icon, "polygon");
                geo = currentLinework();
                geo.setGeometryProperty(Geometry::e_shape_type, "polygon");
                geo.setGeometryProperty(Geometry::e_thickness, poly.thickness);
            }
            else if (poly.flags[PolylineData::e_is_polyface_mesh])
            {
                m_current_mode = DXFMode::e_polyface;
                if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                    currentEntity().setProperty(DesignObject::e_icon, "mesh");
                geo = currentPolyMesh();
                geo.setGeometryProperty(Geometry::e_thickness, poly.thickness);
            }
            else
            {
                m_current_mode = DXFMode::e_polyline;
 
                if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                    currentEntity().setProperty(DesignObject::e_icon, "polyline");
                geo = currentLinework();
                geo.setGeometryProperty(Geometry::e_shape_type, "polyline");
                geo.setGeometryProperty(Geometry::e_thickness, poly.thickness);
            }
            Matrix<fltp08> trans(1.0);
            //in OCS when 2D, WCS when 3D
            if (poly.flags[PolylineData::e_is_3D_polygon] || poly.flags[PolylineData::e_is_3D_polyline])
            {
                trans = trans.offset(Vector<3, fltp08>(0.0, 0.0, poly.elevation));
                //trans *= GetOrientation(poly.extrusion);
            }
            else
            {
                trans *= GetOrientation(poly.extrusion).invert();
                trans = trans.offset(Vector<3, fltp08>(0.0, 0.0, poly.elevation));
            }
            if (m_current_data.paper_space)
            {
                trans = m_current_data.paper_space_info.paperToModelMatrix() * trans;
            }
            geo.setTransform(trans);
            m_x_data.clear();
            
        }
        virtual void addMesh(CADMeshData& mesh_data) override
        {
            if (m_ignore_current)
                return;
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = mesh_data;
            
;           Geometry geo;
            m_current_mode = DXFMode::e_polyface;
            if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                currentEntity().setProperty(DesignObject::e_icon, "mesh");
            geo = currentPolyMesh();
            if (isNaN(m_position_offset) && mesh_data.vertices.size() > 0)
            {
                if (geo.vertexCount() == 0)
                {
                    m_position_offset = mesh_data.vertices[0];
                    geo.offset(m_position_offset);
                }
                else
                {
                    m_position_offset = geo.getTransform().decomposeOffset();
                }
            }
            geo.addVertices(mesh_data.vertices.size());
            uint04 vertex_offset = geo.vertexOffset();
            for (uint04 i = 0; i < mesh_data.vertices.size(); i++)
                mesh_data.vertices[i] -= m_position_offset;
            geo.setVertices(VertexProperty::Position, mesh_data.vertices);
            geo.addPrimitives(PrimitiveProperty::Outline, mesh_data.face_points.size());
            Geometry::OptimizedPrimitiveDef primitive_setter = geo.optimizedPrimitiveDef(PrimitiveProperty::Outline);
            uint04 next_break_location = 0;
            uint04 last_break_location = 0;
            uint04 index_location = 0;
            for (uint04 i = 0; i < mesh_data.face_points.size(); i++)
            {
                if (i == next_break_location)
                {
                    if (i > 0)
                    {
                        Geometry::OptimizedSetPrimitive(primitive_setter, index_location++, mesh_data.face_points[last_break_location] + vertex_offset);
                        last_break_location = next_break_location + 1;
                        geo.addPrimitive(PrimitiveProperty::Outline, Constant<uint04>::NaN);
#ifdef _DEBUG
                        primitive_setter.index_max_offset++;
#endif
                        Geometry::OptimizedSetPrimitive(primitive_setter, index_location++, Constant<uint04>::NaN);
 
                    }
                    next_break_location += (mesh_data.face_points[i] + 1);
                }
                else
                {
                    Geometry::OptimizedSetPrimitive(primitive_setter, index_location++, mesh_data.face_points[i] + vertex_offset);
                }
            }
            if (!isNaN(mesh_data.data_dictionary_reference))
                m_mesh_object_dictionary_listeners.add(mesh_data.data_dictionary_reference, geo.uuid());
            m_x_data.clear();
            endSection();
 
        }
        virtual void addVertex(const Vector<4, fltp08>& vertex) override
        {
            if (m_ignore_current)
                return;
            if (isNaN(vertex[X]) || isNaN(vertex[Y]))
            {
                m_logger.addMessage(LogMessage(_t("Invalid Vertex"), LogMessage::e_warning));
                return;
            }
            WLock lock = m_model_lookup->writeLock();
            switch (m_current_mode)
            {
            default:
                lib_assert(false, "Unexpected Object in add vertex");
                break;
            case DXFMode::e_leader:
            case DXFMode::e_polyline:
            case DXFMode::e_closed_polyline:
            {
                Geometry geo = currentLinework();
                if (isNaN(m_position_offset))
                {
                    m_position_offset = vertex.as<3, fltp08>();
                    geo.offset(m_position_offset);
                }
                if (isNaN(m_next_bulge) || m_next_bulge == 0.0)
                {
                    uint04 index = geo.addVertex();
                    geo.setVertex(VertexProperty::Position, index, vertex.as<3, fltp08>() - m_position_offset);
                    geo.addPrimitive(PrimitiveProperty::Outline, index);
                }
                else// need to calculate bulge
                {
                    fltp08 bulge = m_next_bulge;
                    Vertex<3, fltp08> p1 = geo.vertex<Vertex<3, fltp08>>(VertexProperty::Position, geo.vertexCount() - 1);
                    Vertex<3, fltp08> p2 = vertex.as<3, fltp08>() - m_position_offset;
                    addBulge(geo, bulge, p1, p2);
                }
                m_next_bulge = vertex[D];
            } break;
            case DXFMode::e_polyface:
            {
                Geometry geo = currentPolyMesh();
                if (geo.vertexCount() == 0)
                {
                    geo.offset(vertex.as<3, fltp08>());
                }
                Vector<3, fltp08> offset = geo.getTransform().decomposeOffset();
                uint04 index = geo.addVertex();
                
                geo.setVertex(VertexProperty::Position, index, vertex.as<3, fltp08>() - offset);
            } break;
            }
        }
        virtual void addIndex(const Vector<4, sint04>& vertex) override
        {
            if (m_ignore_current)
                return;
            WLock lock = m_model_lookup->writeLock();
            switch (m_current_mode)
            {
            case DXFMode::e_polyline:
            case DXFMode::e_closed_polyline:
            case DXFMode::e_leader:
            {
                
            } break;
            case DXFMode::e_polyface:
            {
                for (uint04 i = 0; i < 4; i++)
                {
                    if (vertex[i] == 0)
                        break;
                    if(!isNaN(vertex[i]) && abs(vertex[i]) - 1 < cast<sint04>(currentPolyMesh().vertexCount()))
                        currentPolyMesh().addPrimitive(PrimitiveProperty::Outline, abs(vertex[i]) - 1);
                    else
                        m_logger.addMessage(LogMessage(_t("Invalid Vertex Index"), LogMessage::e_warning));
                }
                currentPolyMesh().addPrimitive(PrimitiveProperty::Outline, Constant<uint04>::NaN);
            } break;
            default:
            {
                lib_assert(false, "Unexpected Object in add vertex");
            } break;
            }
        }
        
        virtual void addInsert(const BlockInsert& data) override
        {
            if (m_ignore_current)
                return;
            endSection();
            if (data.block_name == m_current_block_name)
            {
                m_logger.addMessage(LogMessage(_t("Tried to add insert of block inside of block: [block]").replace("[block]",m_current_block_name), LogMessage::e_warning));
                return;
            }
            m_current_data = cast<EntityData>(data);
            //if(m_handle_manager->hasHandleIndex(data.block_name))
                //m_current_data.handle = m_handle_manager->getHandleIndex(data.block_name);
            Matrix<fltp08> mat = GetOrientation(data.extrusion).invert();
            if (!isNaN(data.offset))
                mat = mat.offset(data.offset);
            if (!isNaN(data.azimuth))
                mat = mat.rotate(data.azimuth, Vector<3, fltp08>(0.0, 0.0, 1.0));
            if (!isNaN(data.scale) && data.scale != 1.0)
                mat = mat.scale(data.scale);
            if (m_current_data.paper_space)
            {
                mat = m_current_data.paper_space_info.paperToModelMatrix() * mat;
            }
 
            WLock lock = m_model_lookup->writeLock();
            Model current = currentEntity();
            current.setDesignVisible(data.visible);
            current.setProperty(DesignObject::e_tree_visible, true);
            
            current.setTransform(mat);
            if (!m_blocks.hasKey(data.block_name))
            {
                m_blocks_to_insert[data.block_name].add(current);
                m_child_blocks_to_insert.add(current.uuid(), data.block_name);
            }
            else
            {
                lib_assert(!m_blocks_to_insert.contains(data.block_name), "This should have been resolved");
                Model block = getBlockModel(data.block_name);
                copyBlock(current, block);
            }
            m_last_insert = current.uuid();
            m_x_data.clear();
            endSection();
        }
        virtual void addSpline(const SplineData&) override 
        { 
            if (m_ignore_current)
                return;
            endSection();
        }
    #if NDEVR_VIEWPORT && NDEVR_MEASURE_MODELS
        void addDimAlign(const DimAlignedData& dimension) override
        {
            if (m_ignore_current)
                return;
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = dimension;
            m_current_mode = DXFMode::e_measurement;
            DistanceMeasureModel current_model = DistanceMeasureModel(currentEntity());
            BitFlag point_types(0);
            point_types(MeasurePointType::e_arrow, true);
            current_model.setPointTypes(point_types);
            current_model.setEndpoints(dimension.alignment_data[A], dimension.alignment_data[B], dimension.definition_point);
            TranslatedString location = TranslatedString(String(dimension.alignment_data.length<fltp08>()).formatNumberString(2));
            current_model.setLabel(location);
            current_model.updateProperty(DesignObject::e_name, location);
            current_model.updateModifiedTime();
 
        }
        void addDimLinear(const LinearDimension& dimension) override
        { 
            if (m_ignore_current)
                return;
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = dimension;
            m_current_mode = DXFMode::e_measurement;
            DistanceMeasureModel current_model = DistanceMeasureModel(currentEntity());
            BitFlag point_types(0);
            point_types(MeasurePointType::e_arrow, true);
            current_model.setPointTypes(point_types);
            current_model.setEndpoints(dimension.alignment_data[A], dimension.alignment_data[B], dimension.definition_point);
            TranslatedString location = TranslatedString(String(dimension.alignment_data.length<fltp08>()).formatNumberString(2));
            current_model.setLabel(location);
            current_model.updateProperty(DesignObject::e_name, location);
            current_model.updateModifiedTime();
        }
    #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
        {
            if (m_ignore_current)
                return;
            endSection();
            WLock lock = m_model_lookup->writeLock();
            m_current_data = data;
            Geometry geo;
            m_current_mode = DXFMode::e_leader;
            if (currentEntity().getProperty<String>(DesignObject::e_icon).size() == 0)
                currentEntity().setProperty(DesignObject::e_icon, "polyline");
            geo = currentLinework();
            geo.setGeometryProperty(Geometry::e_shape_type, "polyline");
            Matrix<fltp08> trans(1.0);
            //in OCS when 2D, WCS when 3D
 
            {
                //trans = trans.offset(Vector<3, fltp08>(0.0, 0.0, poly.elevation));
                //trans *= GetOrientation(poly.extrusion);
            }
            if (m_current_data.paper_space)
            {
                trans = m_current_data.paper_space_info.paperToModelMatrix() * trans;
            }
            geo.setTransform(trans);
        }
        
 
        virtual void addComment(const String& comment) override
        { 
            if (m_log_features) 
                m_logger.addMessage(comment); 
        }
#if NDEVR_TEXT_MODEL
        void setupTextData(Text& text, const TextData& data)
        {
            Buffer<TextBlock> text_block_data = parseString(data.text, data.height);
            WLock lock = m_model_lookup->writeLock();
            if (data.line_spacing_factor != 1.0)
                text.setLineSpaceFactor(data.line_spacing_factor);
            text.setText(text_block_data);
            Matrix<fltp08> mat = GetOrientation(data.extrusion).invert();
            if ((data.alignment == (cast<uint01>(TextAlignment::e_left) | cast<uint01>(TextAlignment::e_bottom_base)))
                || isNaN(data.align_b))
                mat = mat.offset(data.align_a);
            else
                mat = mat.offset(data.align_b);
            mat = mat.rotate(data.rotatation + Angle<fltp08>(DEGREES, 90.0), Vector<3, fltp08>(0, 0, 1));
            if (m_text_face_camera)
                mat = mat.scale(0.001);
            if (!m_model_lookup->hasLayerID(text.textLayer().uuid(), currentRoot().uuid()))
                m_model_lookup->addLayer(text.textLayer());
            text.setConstrainedSize(Vector<2, fltp08>(Constant<fltp08>::NaN, data.height));
            text.setReferenceSize(Vector<2, fltp08>(data.reference_width, Constant<fltp08>::NaN));
            text.setAlignment(data.alignment);
            text.setInsertionAlignment(data.alignment);
            //text.textObject().setParentMatrixFlag(Model::ParentMatrixFlags::e_ignore_scale, true);
            if (m_current_data.paper_space)
            {
                mat = m_current_data.paper_space_info.paperToModelMatrix() * mat;
            }
            text.setTransform(mat);
            text.setFaceCamera(m_text_face_camera);
            if (text_block_data.size() > 0)
                text.setProperty(DesignObject::e_name, text_block_data[0].text);
            text.update();
        }
    #endif
        virtual void endEntity() override
        {
            endSection();
        }
        void setAttributes(const DXFAttributes&) override
        {
            endEntity();
        }
 
        void setExtrusion(fltp08 dx, fltp08 dy, fltp08 dz, fltp08 elevation) override
        {
            m_extrusion.setDirection(dx, dy, dz);
            m_extrusion.setElevation(elevation);
        }
 
        Extrusion& getExtrusion() {
            return m_extrusion;
        }
        Scene paperRoot()
        {
            if (!isNaN(m_current_paper_root))
                return m_model_lookup->scene(m_current_paper_root);
            else
                return Scene();
        }
        Buffer<Model> modelRoots() const
        {
            Buffer<Model> roots;
            for (const UUID& id : m_model_roots)
            {
                roots.add(m_model_lookup->model(id));
            }
            return roots;
        }
        Scene currentRoot()
        {
            if (m_current_data.paper_space)
            {
                if (isNaN(m_current_paper_root))
                {
                    WLock lock = m_model_lookup->writeLock();
                    Scene scene(_t("Paper Space"));
                    m_current_paper_root = scene.uuid();
                    scene.createDefaultMaterial();
                    m_model_lookup->addScene(scene);
                }
                return m_model_lookup->scene(m_current_paper_root);
            }
            else
            {
                if (m_model_roots.size() == 0)
                {
                    WLock lock = m_model_lookup->writeLock();
                    Scene scene(_t("Model Space"));
                    scene.setMetaData("is_cad_core", true);
                    m_core_root = scene.uuid();
                    if (m_group_import)
                        m_model_roots.add(m_core_root);
                    else
                        scene.setProperty(DesignObject::e_tree_visible, false);
                    m_model_lookup->addScene(scene);
                }
                return m_model_lookup->scene(m_core_root);
            }
        }
        Model currentBlock()
        {
            if (!isNaN(m_current_block))
            {
                return m_model_lookup->model(m_current_block);
            }
            if (m_current_block_name.size() > 0)
            {
                return getBlockModel(m_current_block_name);
            }
            return currentRoot();
        }
        Buffer<TextBlock> parseString(const String& text, fltp08 default_height)
        {
            Buffer<Font> font_stack;
            Buffer<TextBlock> blocks;
            blocks.add(TextBlock());
            blocks.last().font = FontEngine::ApplicationFont(FontEngine::DefaultFont);
            blocks.last().font.point_size = default_height;
            for (uint04 i = 0; i < text.size(); i++)
            {
                switch (text[i])
                {
                case '{':
                {
                    font_stack.add(blocks.last().font);
                } break;
                case '}':
                {
                    lib_assert(font_stack.size() > 0, "unexpected \"}\"");
                    if (font_stack.size() == 0)
                    {
                        m_logger.addMessage(LogMessage(_td("unexpected_dxf_text_close", "unexpected \"}\"").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                        continue;
                    }
                    if (blocks.last().text.size() > 0)
                    {
                        blocks.add(TextBlock());
                        blocks.last().font = font_stack.last();
                        blocks.last().text.clear();
                    }
                    else
                    {
                        blocks.last().font = font_stack.last();
                    }
                    font_stack.removeLast();
                } break;
                case '\\':
                {
                    Font f = blocks.last().font;
                    i++;
                    lib_assert(i < text.size(), "unexpected end of text");
                    if (i >= text.size())
                    {
                        m_logger.addMessage(LogMessage(_td("unexpected_dxf_text", "Unexpected Font").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                        break;
                    }
                    switch (text[i])
                    {
                    case 'f':
                    case 'F':
                    {
                        i++;
                        lib_assert(i < text.size(), "unexpected end of text");
                        if (i >= text.size())
                        {
                            m_logger.addMessage(LogMessage(_td("unexpected_dxf_text", "Unexpected Font").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                            break;
                        }
                        for (; i < text.size() && text[i] != ';' && text[i] != '|'; i++)
                        {
                            f.name.add(text[i]);
                        }
                        while (i < text.size() && text[i] != ';')
                        {
                            switch (text[i++])
                            {
                            case 'b': f.is_bold = text[i++] == '1'; break;
                            case 'i': f.is_italic = text[i++] == '1'; break;
                            case 'c': while (text[i] != ';' && text[i] != '|') i++; break;
                            case 'p': while (text[i] != ';' && text[i] != '|') i++; break;
                            }
                        }
                        blocks.last().font.getFile().clear();
                    } break;
                    case 's':
                    case 'S':
                    {
                        i++;
                        lib_assert(i < text.size(), "unexpected end of text");
                        if (i >= text.size())
                        {
                            m_logger.addMessage(LogMessage(_td("unexpected_dxf_format", "Unexpected Text Format").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                            break;
                        }
                        while (i < text.size() && text[i] != '#' && text[i] != '^' && text[i] != '/')
                            blocks.last().text.add(text[i++]);
                        blocks.last().text.add('/');
                        while (i < text.size() && text[i] != ';')
                            blocks.last().text.add(text[i++]);
                        lib_assert(i < text.size(), "unexpected end of text");
                        if (i >= text.size())
                        {
                            m_logger.addMessage(LogMessage(_td("unexpected_dxf_format", "Unexpected Text Format").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                            break;
                        }
                    } break;
                    case 'h':
                    case 'H':
                    {
                        i++;
                        String num;
                        while (i < text.size() && text[i] != ';')
                            num.add(text[i++]);
                        f.point_size = num.getAs<fltp08>();
                    }
                    case 'w':
                    case 'W':
                    {
                        i++;
                        String num;
                        while (i < text.size() && text[i] != ';')
                            num.add(text[i++]);
                        f.fixed_width = num.getAs<fltp08>();
                    }
                    case 'c':
                    case 'C':
                    {
                        i++;
                        String num;
                        while (i < text.size() && text[i] != ';')
                            num.add(text[i++]);
                        f.color = RGBColor(ACIColor(abs(num.getAs<sint04>())));
                    }
 
                    case 'L': f.is_underline = true; break;
                    case 'l': f.is_underline = false; break;
                    case 'O': f.is_overstrike = true; break;
                    case 'o': f.is_overstrike = false; break;
                    case 'K': f.is_strikethrough = true; break;
                    case 'k': f.is_strikethrough = false; break;
                    case 'A':
                    {
                        i++;
                        lib_assert(i < text.size(), "unexpected end of text");
                        if (i >= text.size())
                        {
                            m_logger.addMessage(LogMessage(_td("unexpected_dxf_format", "Unexpected Text Format").translation() + ": " + String::toHex(m_current_data.parent_handle) + " : " + String(m_current_data.file_line_number), LogMessage::e_warning));
                            break;
                        }
                        switch (text[i])
                        {
                        case 0: f.alignment = cast<uint01>(TextAlignment::e_bottom); break;
                        case 1: f.alignment = cast<uint01>(TextAlignment::e_center); break;
                        case 2: f.alignment = cast<uint01>(TextAlignment::e_top); break;
                        }
                        if (i < text.size() - 1)
                        {
                            if (text[i + 1] == ';' || text[i + 1] == '|')
                            {
                                i++;
                            }
                        }
 
                    } break;
                    case 'p':
                    {
                        String s;
                        while (text[i] != ';' && text[i] != '|') 
                            s.add(text[i++]);
                        switch (s.hashLower())
                        {
                        case String::hash("pxqc"): f.alignment |= cast<uint01>(TextAlignment::e_center); break;//center
                        case String::hash("pxqr"): f.alignment |= cast<uint01>(TextAlignment::e_right); break;//right aligned
                        case String::hash("pxql"): f.alignment |= cast<uint01>(TextAlignment::e_left); break;//left aligned
                        }
                    } break;
                    case 'P': blocks.last().text.add('\n'); break;
                    case '~': blocks.last().text.append(" "); break;
                    default:
                    {
                        blocks.last().text.add(text[i]);
                    }
                    }
                    if (f != blocks.last().font)
                    {
                        if (blocks.last().text.size() > 0)
                        {
                            blocks.add(TextBlock());
                            blocks.last().font = f;
                            blocks.last().text.clear();
                        }
                        else
                        {
                            blocks.last().font = f;
                        }
                    }
                } break;
                case '%':
                {
                    if (i + 2 < text.size() && text[i + 1] == '%')
                    {
                        //Control Codes and Special Characters Reference
                        i += 2;
                        Font f = blocks.last().font;
                        switch (text[i])
                        {
                        case 'o': f.is_overstrike = !f.is_overstrike; break;
                        case 'u': f.is_underline = !f.is_underline; break;
                        case 'd': blocks.last().text.append(UnitDefinitions::Degrees().get().abbreviation().translation()); break;
                        //case 'p': blocks.last().text.append(""); break;
                        //case 'c': blocks.last().text.append(""); break;
                        case '%': blocks.last().text.append("%"); break;
                        }
                        if (f != blocks.last().font)
                        {
                            if (blocks.last().text.size() > 0)
                            {
                                blocks.add(TextBlock());
                                blocks.last().font = f;
                                blocks.last().text.clear();
                            }
                            else
                            {
                                blocks.last().font = f;
                            }
                        }
                    }
                    else
                    {
                        blocks.last().text.add(text[i]);
                    }
                } break;
                default:
                {
                    blocks.last().text.add(text[i]);
                } break;
                }
            }
            return blocks;
        }
        void addBulge(Geometry& geo, fltp08 bulge, const Vertex<3, fltp08>& p1, const Vertex<3, fltp08>& p2)
        {
            /*lib_assert(!isNaN(bulge) && bulge != 0.0, "Bad bulge");
            if (isNaN(bulge) || bulge == 0.0)
            {
                m_logger.addMessage(LogMessage(_t("Invalid Bulge") + ": " + String(m_current_data.file_line_number), LogMessage::e_warning));
                return;
            }
            Vertex<3, fltp08> arc_mid;
            Vertex<3, fltp08> arc_center;
            fltp08 radius;
            fltp08 chord;
            fltp08 chordMidX;
            fltp08 chordMidY;
            fltp08 sagitta;
            fltp08 apothem;
            Angle<fltp08> inc_angle;
            bool clockwise;
            ArcDataFromBulge(bulge, p1, p2, arc_mid
                , arc_center, radius, &chord, &chordMidX, &chordMidY
                , &sagitta, &apothem, inc_angle);
 
            Angle start_angle = -AngleDefinitions::Heading<sint04>(p1 - arc_center);
            Matrix<fltp08> mat(1.0);
            mat = mat.offset(arc_center);
            mat = mat.scale(Vector<3, fltp08>(-1.0, 1.0, 1.0));
            ShapeConstructors::Circle(geo, mat, 42, radius, start_angle, inc_angle.toTypeAngle<sint04>(), false);
            */
            
            lib_assert(!isNaN(bulge) && bulge != 0.0, "Bad bulge");
            if (isNaN(bulge) || bulge == 0.0)
            {
                m_logger.addMessage(LogMessage(_t("Invalid Bulge").translation() + ": "+ String(m_current_data.file_line_number), LogMessage::e_warning));
                return;
            }
            fltp08 dist = distance<fltp08>(p1, p2);
            fltp08 H = abs(bulge) * dist / 2.0;
            fltp08 r = H / 2.0 + dist / abs(bulge * 4.0);
 
            fltp08 mag_x = (p2[X] - p1[X]) / dist;
            fltp08 mag_y = (p2[Y] - p1[Y]) / dist;
            fltp08 dx = dist / 2.0;
            fltp08 dy = (r - H) * (bulge < 0 ? -1 : 1);
 
            Vector<3, fltp08> center;
            center[X] = mag_x * dx - mag_y * dy + p1[X];
            center[Y] = mag_y * dx + mag_x * dy + p1[Y];
            center[Z] = p1[Z];
 
            //Vector<3, fltp08> p1_ray = p1 - center;
            //fltp08 norm = p1_ray.magnitude<fltp08>();
 
            //Angle start_angle = -Angle::acos(cast<fltp04>(p1_ray[X] / norm));
            //if (p1_ray[Y] < 0.0)
                //start_angle = Angle(DEGREES, 360.0) - start_angle;
 
            Angle<fltp08> start_angle = AngleDefinitions::Heading<fltp08>(p1 - center);
            Angle<fltp08> end_angle = AngleDefinitions::Heading<fltp08>(p2 - center);
            if (end_angle < start_angle)
                end_angle += Angle<fltp08>(DEGREES, 360.0);
            Angle<fltp08> phi = end_angle - start_angle;//-4.0f * Angle::atan(cast<fltp04>(bulge));
 
            if (bulge < 0.0)
                phi = -(Angle<fltp08>(DEGREES, 360.0) - phi);//-4.0f * Angle::atan(cast<fltp04>(bulge));
            
            //start_angle -= phi / 44;//since first vertex is already in polyline, skip it
            //phi -= phi / 22;//subtract the extra from phi, as we are including the start and end vertex manually
            Matrix<fltp08> mat = Matrix<fltp08>::OffsetMatrix(center);
            ShapeConstructors::Circle(geo, mat, 42, r, start_angle, phi, false);
            const uint04 index = geo.addVertex();
            geo.setVertex(VertexProperty::Position, index, p2);
            geo.setPrimitive(PrimitiveProperty::Outline, geo.primitiveCount(PrimitiveProperty::Outline) - 1, index);
        }
        Geometry createGeometry()
        {
            Model model = currentEntity();
            Geometry geo = model.getGeometry();
            if(geo.isValid() && m_current_geometry == model.getGeometry())
            {
                m_current_geometry.clearVerticesAndPrimitives();
                m_current_geometry.updateTransform(Matrix<fltp08>(1.0));
            }
            else
            {
                m_current_geometry = model.createChildGeometry();
            }
            return m_current_geometry;
        }
        Model currentEntity()
        {
            if (isNaN(m_current_entity))
            {
                Model model;
                UUID uuid = Constant<UUID>::NaN;
                if (!isNaN(m_current_data.handle))
                {
                    uuid = m_handle_manager->getHandleUUID(m_current_data.handle);
                    model = m_model_lookup->model(uuid);
                    if (model.isValid())
                    {
                        model.updateTransform(Matrix<fltp08>(1.0));
                        model.setModelProperty(Model::e_fixed_bounding_box, Constant<Bounds<3, fltp08>>::NaN);
                        if(!model.getParent().isValid())
                            m_model_roots.add(model.uuid());
                        //model.removeChild()
                    }
                }
                if (m_group_import || !isNaN(m_current_block))
                {
                    Model block = currentBlock();
                    if (!model.isValid())
                        model = block.createChild();
                    else if (model.getParent() != block)
                        block.addChild(model);
                }
                else if (!model.isValid())
                {
                    model = currentRoot().createSceneModel();
                    m_model_roots.add(model.uuid());
                }
                if(!isNaN(uuid))
                    model.setProperty(DesignObject::e_guid, uuid);
                model.setDesignVisible(m_current_data.visible);
                setupEntityMaterial(model);
                setupLayer(model);
                model.updateModifiedTime();
                if(!m_model_lookup->hasModelID(model.uuid()))
                    m_model_lookup->addModel(model);
                m_current_entity = model.uuid();    
                
                //lib_assert(m_current_data.block.size() > 0 || !model.getRootMaterial(PrimitiveProperty::Solid).isValid(), "Entity missing material");
                /*if (!isNaN(m_current_data.parent_handle) && !model.getRootMaterial(PrimitiveProperty::Solid).isValid())
                {
                    model.getScene().createDefaultMaterial();
                    m_logger.addMessage(LogMessage(_t("Entity Missing Material").translation() + ": " + String(m_current_data.file_line_number), LogMessage::e_warning));
                }*/
                return model;
            }
            return m_model_lookup->model(m_current_entity);
        }
 
        void setVariableInt(const String& label, int value, int key_label) override
        {
            UNUSED(key_label);
            switch (label.hash())
            {
            case String::hash("$INSUNITS"):
            {
                ConstPointer<Unit> unit = ConvertFromCADUnit(value);
                if(!unit.isNull())
                    unit = UnitDefinitions::EastingNorthingElevation(unit.get());
            } break;
 
            case String::hash("$DIMAUNIT"):
            {
                switch (value)
                {
                case 0: m_dim_options.angle_unit = UnitDefinitions::Degrees(); break;
                case 1: m_dim_options.angle_unit = UnitDefinitions::DegreesMinutesSeconds(); break;
                case 2: m_dim_options.angle_unit = UnitDefinitions::Gradians(); break; 
                case 3: m_dim_options.angle_unit = UnitDefinitions::Radians(); break;
                }
                
            } break;
            /*case String::hash("$MEASUREMENT"):
            {
                if (m_unit.isNull())
                {
                    switch (value)
                    {
                    case 0: m_unit = UnitManager::EastingNorthingElevation(UnitManager::Feet().get()); break;
                    case 1: m_unit = UnitManager::EastingNorthingElevation(UnitManager::Meters().get()); break;
                    default: lib_assert(false, "Unknown MEASUREMENT Unit"); break;
                    }
                }
            } break;*/
            }
        }
        /*void setVariableString(const String& label, const String& value, int key_label) override
        {
            switch (label.hash())
            {
            case String::hash("$INSUNITS"):
            {
                String unit = label;
            } break;
            }
        }*/
        Geometry currentLinework()
        {
            if (!m_current_linework.isValid())
            {
                m_current_linework = createGeometry(); 
 
                auto entity = currentEntity();
 
                if (m_x_data.hasKey("CGISCE_F2FC_2000"))
                    entity.setProperty(DesignObject::e_name, m_x_data["CGISCE_F2FC_2000"]);
                else if (entity.getProperty<String>(DesignObject::e_name).size() == 0)
                    entity.setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Linework"), m_linework_read.size()));
                m_linework_read.add(m_current_linework.uuid());
                m_current_linework.setGeometryType(GeometryType::e_linework);
                m_current_linework.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F, Geometry::e_no_vertex
                    , m_color_by_vertex ? Geometry::VertexMode::e_color_rgb : Geometry::VertexMode::e_no_vertex);
                m_current_linework.updateModifiedTime();
            }
            return m_current_linework;
        }
        Geometry& currentTriMesh()
        {
            if (!m_current_mesh.isValid())
            {
                m_current_mesh = createGeometry();
                if (currentEntity().getProperty<String>(DesignObject::e_name).size() == 0)
                    currentEntity().setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Mesh"), m_meshes_read.size()));
                m_meshes_read.add(m_current_mesh.uuid());
                m_current_mesh.setGeometryType(GeometryType::e_triangles);
                m_current_mesh.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F, Geometry::e_no_vertex
                    , m_color_by_vertex ? Geometry::VertexMode::e_color_rgb : Geometry::VertexMode::e_no_vertex);
                m_current_mesh.updateModifiedTime();
            }
            return m_current_mesh;
        }
        Geometry& currentPolyMesh()
        {
            if (!m_current_mesh.isValid())
            {   
                m_current_mesh = createGeometry();
                if(currentEntity().getProperty<String>(DesignObject::e_name).size() == 0)
                    currentEntity().setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Mesh"), m_meshes_read.size()));
                m_meshes_read.add(m_current_mesh.uuid());
                m_current_mesh.setGeometryType(GeometryType::e_convex_polygons);
                m_current_mesh.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F, Geometry::e_no_vertex
                    , m_color_by_vertex ? Geometry::VertexMode::e_color_rgb : Geometry::VertexMode::e_no_vertex);
                m_current_mesh.updateModifiedTime();
            }
            return m_current_mesh;
        }
        Geometry currentCloud()
        {
            if (!m_current_points.isValid())
            {
                m_current_points = createGeometry();
                m_current_points.setProperty(DesignObject::e_icon, "points");
                auto entity = currentEntity();
                if (m_x_data.hasKey("PNTNO"))
                {
                    entity.setProperty(DesignObject::e_name, m_x_data["PNTNO"]);
                    m_point_name_data[m_x_data["PNTNO"]] = entity.uuid();
                }
                if (entity.getProperty<String>(DesignObject::e_name).size() == 0)
                    entity.setProperty(DesignObject::e_name, convertFromCADName(String(), _t("Point"), m_points_read.size()));
                m_points_read.add(m_current_points.uuid());
                m_current_points.setGeometryType(GeometryType::e_points);
                m_current_points.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F, Geometry::e_no_vertex
                    , m_color_by_vertex ? Geometry::VertexMode::e_color_rgb : Geometry::VertexMode::e_no_vertex);
                m_current_points.updateModifiedTime();
            }
            return m_current_points;
        }
        const Buffer<UUID>& pointsRead() const { return m_points_read; }
        const Buffer<UUID>& lineworkRead() const { return m_linework_read; }
        const Buffer<UUID>& meshesRead() const { return m_meshes_read; }
 
        static Matrix<fltp08> GetOrientation(const Vector<3, fltp08>& extrusion)
        {
            if (equals(extrusion, Vector<3, fltp08>(0.0, 0.0, 1.0), 0.00001))
                return Matrix<fltp08>(1.0);
            if (equals(extrusion, Vector<3, fltp08>(0.0, 0.0, -1.0), 0.00001))
                return Matrix<fltp08>(-1.0);
            if (abs(extrusion[Y]) < 1.0)
                return Plane<3, fltp08>(extrusion, Vector<3, fltp08>(0.0)).projectionMatrix(Vector<3, fltp08>(0.0, 0.0, -1.0));
            else
                return Plane<3, fltp08>(extrusion, Vector<3, fltp08>(0.0)).projectionMatrix(Vector<3, fltp08>(0.0, 0.0, -1.0));
        }
    public:
        void setGroupImport(bool group_import)
        {
            m_group_import = group_import;
        }
        void setTextFacingCamera(bool text_face_camera)
        {
            m_text_face_camera = text_face_camera;
        }
        void setAutoNameObjects(bool auto_name_objects)
        {
            m_auto_name_objects = auto_name_objects;
        }
        void setIgnoreKnownBlocks(bool ignore_known_blocks)
        {
            m_ignore_known_blocks = ignore_known_blocks;
        }
        
        [[nodiscard]] Buffer<UUID> getAllReadEntities() const
        {
            Buffer<UUID> ids;
            ids.addAll(m_model_roots);
            ids.add(m_current_paper_root);
            ids.addAll(m_linework_read);
            ids.addAll(m_points_read);
            ids.addAll(m_meshes_read);
            for (const auto& id : m_layers)
            {
                ids.add(id.second);
            }
            for (const UUID& id : m_materials_read)
            {
                ids.add(id);
            }
            for (const UUID& id : m_blocks_read)
            {
                ids.add(id);
            }
            return ids;
        }
    protected:
        void setupLayer(Model& model)
        {
            if (m_current_data.layer.size() > 0)
            {
                if (m_current_data.layer != "1" && !m_layers.hasKey(m_current_data.layer))
                {
                    m_logger.addMessage(LogMessage(_t("Entity Missing Layer").translation() + ": " + String(m_current_data.file_line_number), LogMessage::e_warning));
                }
                if (!m_layers.hasKey(m_current_data.layer))
                {
                    _addLayer(LayerData(m_current_data.layer, Vector<8, bool>(false)));
                }
                Model core_layer = getLayer(m_current_data.layer);
                Model layer;
                if (!m_model_lookup->hasLayerID(core_layer.uuid(), model.getScene().uuid()))
                {
                    layer = model.createSceneLayer();
                    layer.copyFrom(core_layer, false, true);
                    m_model_lookup->addLayer(layer);
                }
                else
                {
                    layer = m_model_lookup->layer(core_layer.uuid(), model.getScene().uuid());
                }
                model.setLayer(layer);
            }
        }
    #if NDEVR_TEXT_MODEL
        DynamicPointer<TextConstructor> getTextContructor(const String& font_name, const Font& font)
        {
            if (!m_text_constructors.hasKey(font_name))
            {
                DynamicPointer<TextConstructor> engine = new TextConstructor(font);
 
                m_text_constructors.insert({ font_name, engine });
                return engine;
            }
            return m_text_constructors.get(font_name);
        }
        DynamicPointer<TextConstructor> getTextContructor(const String& font)
        {
            if (!m_text_constructors.hasKey(font))
            {
                DynamicPointer<TextConstructor> engine = new TextConstructor(FontEngine::ApplicationFont(font));
                
                m_text_constructors.insert({ font, engine });
                return engine;
            }
            return m_text_constructors.get(font);
        }
    #endif
    protected:
        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, DynamicPointer<TextConstructor>> m_text_constructors;
    #endif
        Dictionary<uint04, Material> m_materials;
        Dictionary<String, String> m_x_data;
        Dictionary<String, UUID> m_point_name_data;
        String m_last_x_data_label;
        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;
        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;
        Dictionary<String, UUID> m_layers;
        Buffer<UUID> m_model_roots;
        UUID m_core_root;
        UUID m_current_paper_root;
        UUID m_blocks_root;
        UUID m_current_block;
        UUID m_current_entity;
        UUID m_last_insert;
        Geometry m_current_geometry;
        Geometry m_current_linework;
        Geometry m_current_mesh;
        Geometry m_current_points;
        UUID m_current_material;
        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;
        fltp08 m_next_bulge;
        
        DynamicPointer<CADHandleManager> m_handle_manager;
        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;
        DesignObjectLookup* m_model_lookup;
        DXFMode m_current_mode;
        bool m_read_paper_space = false;
        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 = true;
        bool m_ignore_current = false;//when true, ignores any information
        Vertex<3, fltp08> m_position_offset = Constant<Vertex<3, fltp08>>::NaN;
        std::function<void(uint04 value, DXFValueManager* manager)> m_xdata_callback;
        uint04 m_circle_count = 0;
        uint04 m_ellipse_count = 0;
        uint04 m_insert_count = 0;
        uint04 m_attribute_count = 0;
        CADMeshVertexAttributeSetter* m_mesh_attribute_setter = nullptr;
        CADMeshVertexColorSetter* m_mesh_color_setter = nullptr;
        File m_relative_path;
        DimensionOptions m_dim_options;
    };
}