Geometry.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: Geometry
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/DesignObject.h>
#include <NDEVR/Triangle.h>
#include <NDEVR/Polygon.h>
#include <functional>
namespace NDEVR
{
    struct FilterDescription;  
    template<uint01 t_dims, class t_type>
    class Plane;               
    class SelectionInfo;       
    class InfoPipe;            
    class Scene;               
    class Log;                 
    class RGBColor;            
    class Geometry;            
    enum class NDPG
    {
          geometry_type              
        , thickness                  
        , thickness_mode             
        , winding                    
        , property_fields            
        , is_surface                 
        , has_closed_primitive        
        , plane_normal               
        , plane_offset               
        , poly_holes                 
        , is_smooth                  
        , smooth_algorithm           
        , smooth_level               
        , normal_mode                
        , normal_smoothing_angle     
        , is_closed_solid            
        , shape_type                 
        , is_clipping_geo            
        , preserve_primitive_order   
        , preserve_vertex_order      
        , no_auto_tree_creation      
    };

    template<> struct PropertySpec<NDPG::geometry_type> { using type = StringView; };
    template<> struct PropertySpec<NDPG::thickness> { using type = fltp04; };
    template<> struct PropertySpec<NDPG::thickness_mode> { using type = uint01; };
    template<> struct PropertySpec<NDPG::is_surface> { using type = bool; };
    template<> struct PropertySpec<NDPG::has_closed_primitive> { using type = bool; };
    template<> struct PropertySpec<NDPG::plane_normal> { using type = Ray<3, fltp08>; };
    template<> struct PropertySpec<NDPG::plane_offset> { using type = fltp08; };
    template<> struct PropertySpec<NDPG::poly_holes> { using type = bool; };
    template<> struct PropertySpec<NDPG::is_smooth> { using type = bool; };
    template<> struct PropertySpec<NDPG::smooth_algorithm> { using type = StringView; };
    template<> struct PropertySpec<NDPG::smooth_level> { using type = uint04; };
    template<> struct PropertySpec<NDPG::normal_smoothing_angle> { using type = fltp04; };
    template<> struct PropertySpec<NDPG::is_closed_solid> { using type = bool; };
    template<> struct PropertySpec<NDPG::shape_type> { using type = StringView; };
    template<> struct PropertySpec<NDPG::is_clipping_geo> { using type = bool; };
    template<> struct PropertySpec<NDPG::preserve_primitive_order> { using type = bool; };
    template<> struct PropertySpec<NDPG::preserve_vertex_order> { using type = bool; };
    template<> struct PropertySpec<NDPG::no_auto_tree_creation> { using type = bool; };

    template<>
    class PropertyColumnInterface<NDPG>
    {
    public:
        static constexpr TableColumn* column(const DesignInfo* object, NDPG property)
        {
            return object->m_base->geometry_properties[eint01(property)];
        }

        static constexpr uint04 index(const DesignInfo* object, NDPG)
        {
            return object->m_design_index;
        }
    };
    
    class NDEVR_DESIGN_API Geometry : public DesignObject
    {
        friend class Model;
    public:
        enum VertexMode : uint01
        {
              e_no_vertex            
            , e_index                
            , e_cartesian_1F         
            , e_cartesian_1D         
            , e_cartesian_2F         
            , e_cartesian_3F         
            , e_cartesian_2D         
            , e_cartesian_3D         
            , e_normal_ray_3F        
            , e_normal_ray_3D        
            , e_cartesian_grid_1F    
            , e_cartesian_grid_3F    
            , e_cartesian_grid_1D    
            , e_cartesian_grid_3D    
            , e_cartesian_grid_image 
            , e_polar_grid_1F        
            , e_color_aci            
            , e_color_hsb            
            , e_color_hsl            
            , e_color_lab            
            , e_color_rgb            
            , e_color_xyz            
            , e_bitflag              
            , e_cartesian_2I         
            , e_cartesian_3I         
            , e_cartesian_2S         
            , e_cartesian_3S         
        };

        enum TreeMode
        {
              e_no_tree    
            , e_r_tree     
            , e_kd_tree    
            , e_quad_tree  
        };

        enum ThicknessMode
        {
              e_none              
            , e_pixel             
            , e_flat_single       
            , e_flat_per_vertex   
            , e_circle            
            , e_circle_per_vertex 
        };
    public:
        Geometry() = default;

        Geometry(DesignObjectBase* base);

        Geometry(uint04 index, DesignObjectBase* base);

        explicit Geometry(const DesignObject& obj);

        void setGeometryType(GeometryType geometry_type);

        GeometryType getGeometryType() const;

        void clearVerticesAndPrimitives();

        void split(Geometry& other_geo, const Buffer<bool>& vertex_mask);

        void combine(Geometry& geo, const Matrix<fltp08>& conversion = Matrix<fltp08>(1.0));

        void copyFrom(const Geometry& geo, bool copy_tree = true, bool copy_vertices = true);

        void copyTraitsFrom(const Geometry& geo);

        inline uint04 parentCount() const;

        Vertex<3, fltp08> faceCenter(uint04 index) const;

        Buffer<LineSegment<3, fltp08>> faceEdges(uint04 index) const;

        ModelBuffer getParents() const;

        inline Model getParent(uint04 index) const;

        void deleteGeometry();

        uint01 parity(const Matrix<fltp04>& parent_matrix, PrimitiveMode mode) const;

        uint01 parity(const Matrix<fltp08>& parent_matrix, PrimitiveMode mode) const;

        void fillHolesByNeighbor(PrimitiveProperty property, const void* lock = nullptr, LogPtr log = LogPtr());

        void removeHoleFill(const void* lock = nullptr, LogPtr log = LogPtr());

        void setWindingMode(WindingMode mode);

        void optimizeVertexLocations();

        void centerAlign();

        void invalidateBounds();

        void setBounds(const Bounds<3, fltp08>& bounds);

        bool canBeClosedSolid(const void* lock = nullptr) const;

        bool hasParent(const Model& model) const;

        void calculateIndexNeighborList(PrimitiveProperty primitive_property);

        Bounds<3, fltp08> getBounds() const;

        bool canExplode() const;

        GeometryBuffer explode() const;

        void outline();

        void setNormalMode(NormalMode mode, Angle<fltp08> max_sep_angle, const void* lock = nullptr, LogPtr log = LogPtr());

        void calculateNormals(NormalMode mode, Angle<fltp08> max_difference, const void* lock = nullptr, LogPtr log = LogPtr());

        void setRealThickness(fltp08 real_thickness, const Matrix<fltp08>& transform, const void* lock, LogPtr log = LogPtr());

        void setThicknessMode(ThicknessMode mode);

        void sortVertices(Buffer<uint04> new_order);

        ThicknessMode thicknessMode() const;

        void flipNormals();

        void removeDuplicateVertices(fltp08 epsilon, const void* lock, LogPtr log = LogPtr());

        void splitDuplicateVertices();

        void convertPolarToCartesian(const StringView& roll_column, const StringView& pitch_column, const StringView& distance_column);
        

        struct SmoothingParameters
        {
            PrimitiveProperty property;      
            uint04 iterations;               
            mutable LogPtr log;              
            const void* lock = nullptr;      
            fltp08 shrink_rate = 0.5;        
            fltp08 grow_rate = -0.53;        
        };

        void laplacianSmoothing(const SmoothingParameters& properties);

        void cotangentLaplacianSmoothing(const SmoothingParameters& properties);

        void clearSmoothing(const SmoothingParameters& properties);

        void calculateTangentSpace(bool calc_tan, bool calc_bitan);

        bool validate() const;

        bool hasHoles(PrimitiveProperty property) const;

        void ensureFlagColumnExists();

        void setVertexFlag(uint04 vertex, VertexFlags flag, bool value);

        void setVerticesFlag(const Buffer<uint04>& vertices, VertexFlags flag, bool value);

        void setVerticesFlag(const Buffer<bool>& selection_mask, VertexFlags flag, bool value);

        void setVerticesFlags(const Buffer<bool>& selection_mask, BitFlag on_flags, BitFlag off_flags);

        void setVerticesFlags(const Buffer<bool>& selection_mask, BitFlag selected_on_flags, BitFlag selected_off_flags, BitFlag unselected_on_flags, BitFlag unselected_off_flags, uint04 bitmask_offset = 0);

        void setVerticesFlagAll(VertexFlags flag, bool value);

        void setVerticesFlagAll(uint01 on_flags, uint01 off_flags);

        void setPrimitiveIndexFlag(PrimitiveProperty property, uint04 primitive_index, PrimitiveBitFlags flag, bool value);

        bool primitiveIndexFlag(PrimitiveProperty property, uint04 primitive_index, PrimitiveBitFlags flag) const;

        bool vertexFlag(uint04 vertex_index, VertexFlags flag) const;

        BitFlag vertexFlag(uint04 vertex_index) const;

        Buffer<uint04> getSelectedVertices() const;

        bool vertexSelected(uint04 vertex) const;

        void setGeometryTransform(const Matrix<fltp08>& transform);

        void updateGeometryTransform(const Matrix<fltp08>& transform, const void* lock_ptr = nullptr);

        StringView getGeometryIcon() const;
        bool operator==(const Geometry& geo) const
        {
            if (!isValid() || !geo.isValid())
                return isValid() == geo.isValid();
            return (m_base == geo.m_base && m_index == geo.m_index);
        }

        bool operator!=(const Geometry& geo) const
        {
            if (!isValid() || !geo.isValid())
                return isValid() != geo.isValid();
            return (m_base != geo.m_base || m_index != geo.m_index);
        }

        Time getAscModifiedTime(bool include_self, bool include_layer = false) const;

        void normalExpansion(const Vector<3, fltp04>& expansion_vector);
    private:
        Bounds<3, fltp08> _calculateBounds() const;
        
        
        //void getVertexDesignParameters(DesignParameters& params, const Matrix<fltp08>& transform, bool deviation_pass) const;
        
        
    public:

        ColumnT<uint04>& primitiveColumn()
        {
            return m_base->primitive_index_column;
        }

        const ColumnT<uint04>& primitiveColumn() const
        {
            return m_base->primitive_index_column;
        }

        ColumnT<uint04>& primitiveFanColumn()
        {
            return m_base->primitive_fan_column;
        }

        const ColumnT<uint04>& primitiveFanColumn() const
        {
            return m_base->primitive_fan_column;
        }

        ColumnT<uint01>& primitiveFlagColumn()
        {
            return m_base->primitive_flag_column;
        }

        const ColumnT<uint01>& primitiveFlagColumn() const
        {
            return m_base->primitive_flag_column;
        }

        TableColumn& faceToEdgeColumn()
        {
            return *m_base->face_to_edge_column;
        }

        const TableColumn& faceToEdgeColumn() const
        {
            return *m_base->face_to_edge_column;
        }

        TableColumn& edgeToFaceColumn()
        {
            return *m_base->edge_to_face_column;
        }

        const TableColumn& edgeToFaceColumn() const
        {
            return *m_base->edge_to_face_column;
        }

        PrimitiveMode mode(PrimitiveProperty property) const
        {
            return m_base->primitive_property_mode_column[cast<uint01>(property)]->get<PrimitiveMode>(m_design_index);
        }

        bool hasProperty(PrimitiveProperty property) const
        {
            return mode(property) != PrimitiveMode::e_no_index;
        }

        bool hasIndexColumn() const
        {
            return m_base->primitive_index_column.size() > 0;
        }

        bool hasIndexFanColumn() const
        {
            return m_base->primitive_fan_column.size() > 0;
        }

        void reservePrimitiveIndexSpace(uint04 index_size);

        void setPrimitiveRange(PrimitiveProperty mode, uint04 start, uint04 primitive_count);

        void setPrimitiveMode(PrimitiveProperty property, PrimitiveMode mode);

        void updatePrimitiveColumn(PrimitiveProperty property, bool remove_tree = true);

        void updatePrimitiveColumns(bool remove_tree = true);

        void updateModifiedTime(Time time = Time::SystemTime());

        void updateGeometryTime(Time time = Time::SystemTime());

        Plane<3, fltp08> calculatePlaneAtVertex(uint04 vertex_index) const;
        template<class t_type>
        void setPrimitive(PrimitiveProperty property, uint04 index, t_type index_value)
        {
            lib_assert(index < indicesPerPrimitive(mode(property)) * primitiveCount(property), "Bad index set");
            const uint04 index_offset = indexOffset() + indexOffset(property) + index;
            if (IsValid(index_value))
            {
                lib_assert(cast<uint04>(index_value) < vertexCount(), "index for geometry out of range");
                primitiveColumn()[index_offset] = index_value + t_type(vertexOffset());
            }
            else
                primitiveColumn()[index_offset] = Constant<uint04>::Invalid;
        }

        template<class t_type>
        void setPrimitive(PrimitiveProperty property, uint04 index, Vector<2, t_type> index_value)
        {
            lib_assert(index < primitiveCount(property), "Bad index set");
            const uint04 index_offset = indexOffset() + indexOffset(property);
            TableColumn& column = primitiveColumn();
            if (IsValid(index_value))
            {
                lib_assert(index_value[A] < vertexCount(), "index for geometry out of range A");
                lib_assert(index_value[B] < vertexCount(), "index for geometry out of range B");
                index_value += cast<t_type>(vertexOffset());
            }
            else
            {
                index_value = Constant<Vector<2, t_type>>::Invalid;
            }
            switch (mode(property))
            {
            case PrimitiveMode::e_polyline:
                column.set(index_offset + index + A, index_value[A]);
                column.set(index_offset + index + B, index_value[B]);
                break;
            case PrimitiveMode::e_lines:
                column.set(index_offset + 2 * index + A, index_value[A]);
                column.set(index_offset + 2 * index + B, index_value[B]);
                break;
            default:
                lib_assert(false, "Unknown Primitive Mode for vertex<2>");
            }
        }

        struct OptimizedPrimitiveDef
        {
            OptimizedPrimitiveDef()
            {}
            OptimizedPrimitiveDef(ColumnT<uint04>& column, ColumnT<uint04>& fan_column)
                : column(&column)
                , fan_column(&fan_column)
            {}
            ColumnT<uint04>* column = nullptr;     
            ColumnT<uint04>* fan_column = nullptr; 
            uint04 index_offset;                   
            uint04 fan_offset;                     
#ifdef _DEBUG
            uint04 index_max_offset;               
            uint04 min_vertex_index;               
            uint04 max_vertex_index;               
#endif
            PrimitiveMode mode;                    
        };

        OptimizedPrimitiveDef optimizedPrimitiveDef(PrimitiveProperty property)
        {
            OptimizedPrimitiveDef ref(primitiveColumn(), primitiveFanColumn());
            ref.index_offset = indexOffset() + indexOffset(property);
            ref.fan_offset = indexFanOffset();
#ifdef _DEBUG
            ref.min_vertex_index = vertexOffset();
            ref.max_vertex_index = ref.min_vertex_index + vertexCount();
            ref.index_max_offset = primitiveCount(property);
#endif
            ref.mode = mode(property);
            return ref;
        }

        template<class t_vec_type>
        static void OptimizedSetPrimitive(const OptimizedPrimitiveDef& ref, uint04 index, t_vec_type index_value)
        {
#ifdef _DEBUG
            lib_assert(index < ref.index_max_offset, "Index out of bounds");
            for (uint01 i = 0; i < 3; i++)
            {
                lib_assert(IsInvalid(index_value) || index_value >= ref.min_vertex_index, "Index out of bounds");
                lib_assert(IsInvalid(index_value) || index_value < ref.max_vertex_index, "Index out of bounds");
            }
#endif
            (*ref.column)[ref.index_offset + index] = index_value;
        }

        template<class t_vec_type>
        static void OptimizedSetPrimitiveVec(const OptimizedPrimitiveDef& ref, uint04 index, t_vec_type index_value)
        {
#ifdef _DEBUG
            lib_assert(index < ref.index_max_offset, "Index out of bounds");
            for (uint01 i = 0; i < 3; i++)
            {
                lib_assert(IsInvalid(index_value[i]) || index_value[i] >= ref.min_vertex_index, "Index out of bounds");
                lib_assert(IsInvalid(index_value[i]) || index_value[i] < ref.max_vertex_index, "Index out of bounds");
            }
#endif
            switch (ref.mode)
            {
            case PrimitiveMode::e_triangle:
                (*ref.column)[ref.index_offset + 3 * index + A] = index_value[A];
                (*ref.column)[ref.index_offset + 3 * index + B] = index_value[B];
                (*ref.column)[ref.index_offset + 3 * index + C] = index_value[C];
                break;
            case PrimitiveMode::e_triangle_strip:
                (*ref.column)[ref.index_offset + index + A] = index_value[A];
                (*ref.column)[ref.index_offset + index + B] = index_value[B];
                (*ref.column)[ref.index_offset + index + C] = index_value[C];
                break;
            case PrimitiveMode::e_triangle_fan:
            {
                uint04 index_fan_location = (*ref.fan_column)[index + ref.fan_offset];
                if (IsValid(index_fan_location))
                {
                    (*ref.column)[index_fan_location] = index_value[A];
                    (*ref.column)[index + ref.index_offset - 1] = index_value[B];
                    (*ref.column)[index + ref.index_offset] = index_value[C];
                }
            } break;
            default:
                lib_assert(false, "Unknown Primitive Mode for vertex<3>");
            }
        }

        template<class t_vec_type>
        static t_vec_type OptimizedGetPrimitiveVec(const OptimizedPrimitiveDef& ref, uint04 index)
        {
            lib_assert(index < ref.index_max_offset, "Index out of bounds");
            t_vec_type index_value;
            switch (ref.mode)
            {
            case PrimitiveMode::e_lines:
                index_value[A] = (*ref.column)[ref.index_offset + 2 * index + A];
                index_value[B] = (*ref.column)[ref.index_offset + 2 * index + B];
                break;
            case PrimitiveMode::e_polyline:
                index_value[A] = (*ref.column)[ref.index_offset + index + A];
                index_value[B] = (*ref.column)[ref.index_offset + index + B];
                break;
            case PrimitiveMode::e_triangle:
                index_value[A] = (*ref.column)[ref.index_offset + 3 * index + A];
                index_value[B] = (*ref.column)[ref.index_offset + 3 * index + B];
                index_value[C] = (*ref.column)[ref.index_offset + 3 * index + C];
                break;
            case PrimitiveMode::e_triangle_strip:
                index_value[A] = (*ref.column)[ref.index_offset + index + A];
                index_value[B] = (*ref.column)[ref.index_offset + index + B];
                index_value[C] = (*ref.column)[ref.index_offset + index + C];
                break;
            case PrimitiveMode::e_triangle_fan:
            {
                uint04 index_fan_location = (*ref.fan_column)[index + ref.fan_offset];
                if (IsInvalid(index_fan_location))
                {
                    index_value = Constant<t_vec_type>::Invalid;
                }
                else
                {
 
                    lib_assert(index_fan_location >= ref.index_offset && index_fan_location - ref.index_offset < ref.index_max_offset, "bad fan location");
                    index_value[A] = (*ref.column)[index_fan_location];
                    index_value[B] = (*ref.column)[index + ref.index_offset - 1];
                    index_value[C] = (*ref.column)[index + ref.index_offset];
                }
            } break;
            default:
                lib_assert(false, "Unknown Primitive Mode for vertex<3>");
            }
            return index_value;
        }

        template<class t_type>
        void setPrimitive(PrimitiveProperty property, uint04 index, Vector<3, t_type> index_value)
        {
            setPrimitiveVec<t_type>(property, index, index_value);
        }

        template<class t_type>
        void setPrimitive(PrimitiveProperty property, uint04 index, Triangle<1, t_type> index_value)
        {
            setPrimitiveVec<t_type>(property, index, index_value);
        }

        static constexpr uint04 indicesPerPrimitive(PrimitiveMode property)
        {
            switch (property)
            {
            case PrimitiveMode::e_no_index:
                return 0;
            case PrimitiveMode::e_triangle:
                return 3;
            case PrimitiveMode::e_lines:
                return 2;
            default:
                return 1;
            }
        }

        template<class t_type>
        t_type primitive(PrimitiveProperty property, typename std::enable_if<ObjectInfo<t_type>::Dimensions <= 1, uint04>::type index) const
        {
            lib_assert(index < indicesPerPrimitive(mode(property)) * primitiveCount(property), "Out of bounds index request");
            const uint04 index_offset = indexOffset() + indexOffset(property);
            t_type index_value(primitiveColumn()[index_offset + index]);
            if (IsInvalid(index_value))
                return Constant<t_type>::Invalid;
            return index_value - t_type(vertexOffset());
        }

        template<class t_type>
        t_type primitive(PrimitiveProperty property, typename std::enable_if<ObjectInfo<t_type>::Dimensions == 2, uint04>::type index) const
        {
            uint04 primitive_count = primitiveCount(property);
            if (primitive_count == 0)
            {
                lib_assert(index + 1 < vertexCount(), "Out of bounds index request");
                t_type index_value = { index, index + 1 };
                return index_value;
            }
            else
            {
                t_type index_value;
                const uint04 index_offset = indexOffset() + indexOffset(property);
                const TableColumn& column = primitiveColumn();
                switch (mode(property))
                {
                case PrimitiveMode::e_lines:
                    lib_assert(index < primitive_count, "Out of bounds index request");
                    index_value = { column.get<uint04>(index_offset + 2 * index), column.get<uint04>(index_offset + 2 * index + 1) };
                    break;
                case PrimitiveMode::e_polyline:
                    lib_assert(index + 1 < primitive_count, "Out of bounds index request");
                    index_value = { column.get<uint04>(index_offset + index), column.get<uint04>(index_offset + index + 1) };
                    break;
                default:
                    lib_assert(false, "Bad property fetch mode");
                }
 
                if (IsInvalid(index_value))
                    return Constant<t_type>::Invalid;
                return index_value - t_type(vertexOffset());
            }
        }

        template<class t_type>
        t_type primitive(PrimitiveProperty property, typename std::enable_if<ObjectInfo<t_type>::Dimensions == 3, uint04>::type index) const
        {
            lib_assert(index < primitiveCount(property), "Out of bounds index request");
            t_type index_value;
            const uint04 index_offset = indexOffset() + indexOffset(property);
            const ColumnT<uint04>& column = primitiveColumn();
            auto v_mode = mode(property);
            switch (v_mode)
            {
            case PrimitiveMode::e_triangle:
                index_value = {
                      column[index_offset + 3 * index + 0]
                    , column[index_offset + 3 * index + 1]
                    , column[index_offset + 3 * index + 2] };
                break;
            case PrimitiveMode::e_triangle_strip:
                index += index_offset;
                index_value = { 
                      column[index + 0]
                    , column[index + 1]
                    , column[index + 2] };
                break;
            case PrimitiveMode::e_triangle_fan:
            {
                uint04 index_fan_location = primitiveFanColumn()[index + indexFanOffset()];
                if (IsInvalid(index_fan_location))
                    index_value = Constant<t_type>::Invalid;
                else
                    index_value = {
                      column[index_fan_location]
                    , column[index + index_offset - 1]
                    , column[index + index_offset] };
            } break;
            default:
                lib_assert(false, "Bad property fetch mode");
            }
            if (IsInvalid(index_value))
                return Constant<t_type>::Invalid;
            return index_value - t_type(vertexOffset());
        }

        Buffer<uint04> primitiveIndices(PrimitiveProperty primitive_property) const;

        Buffer<uint04> indices(PrimitiveProperty primitive_property, uint04 start, uint04 size) const;

        Buffer<Vector<2, uint04>> lineIndices(PrimitiveProperty primitive_property) const
        {
            return lineIndices(primitive_property, 0, primitiveCount(primitive_property));
        }

        Buffer<Vector<2, uint04>> lineIndices(PrimitiveProperty primitive_property, uint04 start, uint04 size) const;

        Buffer<Vector<3, uint04>> triIndices(PrimitiveProperty primitive_property) const
        {
            return triIndices(primitive_property, 0, primitiveCount(primitive_property));
        }

        Buffer<Vector<3, uint04>> triIndices(PrimitiveProperty primitive_property, uint04 start, uint04 size) const;
        

        uint04 indexOffset() const
        {
            return m_base->index_mode_offset_column[m_design_index];
        }

        uint04 indexOffset(PrimitiveProperty property) const
        {
            return (*m_base->primitive_property_offset_column[eint01(property)])[m_design_index];
        }

        uint04 indexFanOffset() const
        {
            return m_base->index_fan_offset_column[m_design_index];
        }

        uint04 indexFanCount() const
        {
            return m_base->index_fan_size_column[m_design_index];
        }

        template<class t_type>
        uint04 addPrimitive(PrimitiveProperty index_property, const t_type& primitive)
        {
            const uint04 primitive_count = primitiveCount(index_property);
            setPrimitiveRange(index_property, indexOffset(index_property), primitive_count + 1);
            setPrimitive(index_property, primitive_count, primitive);
            return primitive_count;
        }

        uint04 addPrimitives(PrimitiveProperty index_property, uint04 insersion_size)
        {
            const uint04 primitive_count = primitiveCount(index_property);
            setPrimitiveRange(index_property, indexOffset(index_property), primitive_count + insersion_size);
            return primitive_count;
        }

        void closePolyline(PrimitiveProperty property);

        void autoCalculateIndices(PrimitiveProperty property, const void* lock = nullptr, const Matrix<fltp08>& transform = Matrix<fltp08>(1.0), LogPtr log = LogPtr());
    public:
        static void SetTriangulationMethod(std::function<void(Geometry& geo, const Matrix<fltp08>& matrix, const void* lock, LogPtr log)> function);

        uint04 primitiveIndexCount() const
        {
            return m_base->index_mode_size_column[m_design_index];
        }

        uint04 primitiveCount(PrimitiveProperty property) const
        {
            return (*m_base->primitive_property_size_column[cast<uint01>(property)])[m_design_index];
        }

        uint04 primitiveIndexCount(PrimitiveProperty property) const
        {
            return indicesPerPrimitive(mode(property)) * primitiveCount(property);
        }


        uint04 addVertex()
        {
            const uint04 count = vertexCount();
            setVertexCount(count + 1);
            return count;
        }

        uint04 addVertexWithExtraReservedSpace();

        uint04 addVertices(uint04 size)
        {
            const uint04 count = vertexCount();
            setVertexCount(count + size);
            return count;
        }

        void addVertices(uint04 location, uint04 size);

        void setVertexCount(uint04 size, bool deallocate_if_possible = true);

        void removeVertex(uint04 location);

        void removeVertices(uint04 location, uint04 size);

        void removeVertices(Buffer<uint04> vertices);

        void removeVertices(const Buffer<bool>& selection_mask);

        void removeVertices(uint04 mask_offset, const Buffer<bool>& selection_mask);

        void removePrimitive(PrimitiveProperty property, uint04 location);

        void removePrimitive(PrimitiveProperty property, uint04 location, uint04 size);

        void removePrimitive(PrimitiveProperty property, Buffer<uint04> vertices);

        void removePrimitive(PrimitiveProperty property, const Buffer<bool>& selection_mask);

        void createDrapedMaterialCoordinates(const Matrix<fltp08>& mat = Matrix<fltp08>());

        Matrix<fltp08> getCompleteTransform(const Model& parent) const;
        uint04 vertexReservedCount() const
        {
            return m_base->vertex_reserved_count_column[m_design_index];
        }

        uint04 vertexOffset() const
        {
            return m_base->vertex_offset_column[m_design_index];
        }

        uint04 vertexCount() const
        {
            return m_base->vertex_count_column[m_design_index];
        }

        uint04 solidVertexOffset() const
        {
            return m_base->solid_vertex_offset_column[m_design_index];
        }

        uint04 solidVertexReservedCount() const
        {
            return m_base->solid_vertex_reserved_count_column[m_design_index];
        }

        uint04 solidVertexCount() const
        {
            return m_base->solid_vertex_count_column[m_design_index];
        }


        const String& vertexPropertyName(uint04 property_index) const
        {
            return m_base->vertex_table.get(property_index).label();
        }

        uint04 vertexPropertyCount() const;

        uint04 vertexPropertyIndex(const StringView& property_name) const;

        bool hasVertexProperty(const StringView& property_name) const;

        bool hasVertexProperty(const VertexProperty& property) const;

        TypeInfo vertexPropertyType(uint04 property_index) const
        {
            return propertyColumn(property_index).type();
        }

        template<class t_type>
        uint04 createVertexProperty(const StringView& property_name)
        {
            return createVertexProperty(property_name, GetTypeInfo<t_type>());
        }

        uint04 createVertexProperty(const StringView& property_name, const TypeInfo& type);

        template<class t_type>
        t_type vertexProperty(uint04 property_index, uint04 vertex_index) const
        {
            return propertyColumn(property_index).get<t_type>(vertexOffset() + vertex_index);
        }

        template<class t_type>
        t_type vertexProperty(const StringView& property, uint04 vertex_index) const
        {
            return propertyColumn(property).get<t_type>(vertexOffset() + vertex_index);
        }

        template<class t_type>
        t_type vertexProperty(uint04 property_index, uint04 vertex_index, uint04 sub_index) const
        {
            return propertyColumn(property_index).get<t_type>(vertexOffset() + vertex_index, sub_index);
        }

        template<class t_type>
        t_type vertexProperty(const StringView& property, uint04 vertex_index, uint04 sub_index) const
        {
            return propertyColumn(property).get<t_type>(vertexOffset() + vertex_index, sub_index);
        }
 

        template<class t_type>
        void setVertexProperty(uint04 property, uint04 index, const t_type& vector)
        {
            lib_assert(index <= vertexCount(), "Out of bounds vertex set");
            propertyColumn(property).set(vertexOffset() + index, vector);
        }

        template<class t_type>
        void setVertexProperty(const StringView& property, uint04 index, const t_type& property_value)
        {
            lib_assert(index <= vertexCount(), "Out of bounds vertex set");
            propertyColumn(property).set(vertexOffset() + index, property_value);
        }

        template<class t_type>
        void setVertexProperty(uint04 property, uint04 index, uint04 sub_index, const t_type& vector)
        {
            lib_assert(index <= vertexCount(), "Out of bounds vertex set");
            propertyColumn(property).set(vertexOffset() + index, sub_index, vector);
        }

        template<class t_type>
        void setVertexProperty(const StringView& property, uint04 index, uint04 sub_index, const t_type& vector)
        {
            lib_assert(index <= vertexCount(), "Out of bounds vertex set");
            propertyColumn(property).set(vertexOffset() + index, sub_index, vector);
        }

        template<class t_type>
        void setVertexProperties(const StringView& property, const Buffer<t_type>& vertices, uint04 offset = 0)
        {
            lib_assert(offset + vertices.size() <= vertexCount(), "Out of bounds vertex set");
            uint04 vertex_offset = vertexOffset() + offset;
            auto& col = propertyColumn(property);
            for (uint04 i = 0; i < vertices.size(); i++)
            {
                col.set(vertex_offset + i, vertices[i]);
            }
        }


        TableColumn& propertyColumn(uint04 property)
        {
            return m_base->vertex_table[property];
        }

        const TableColumn& propertyColumn(uint04 property) const
        {
            return m_base->vertex_table[property];
        }

        bool hasProperty(VertexProperty property) const
        {
            return mode(property) != VertexMode::e_no_vertex;
        }

        VertexMode mode(VertexProperty property) const
        {
            return m_base->vertex_mode_column[eint01(property)]->get<VertexMode>(m_design_index);
        }

        void setupVertexTable(uint04 vertex_size
            , VertexMode position
            , VertexMode normal = VertexMode::e_no_vertex
            , VertexMode color = VertexMode::e_no_vertex
            , VertexMode texture = VertexMode::e_no_vertex
            , VertexMode tangent = VertexMode::e_no_vertex
            , VertexMode bitangent = VertexMode::e_no_vertex
            , VertexMode bones = VertexMode::e_no_vertex);

        void updateVertexColumn(VertexProperty property);

        void updateVertexColumn(VertexProperty property, uint04 index, uint04 size, bool invalidate_bounds = true, bool erase_kd_tree = true);

        void updateVertexColumn(const StringView& property);

        void updateVertexColumn(const uint04& property);

        void updateVertexColumn(const StringView& property, uint04 index, uint04 size);

        void updateVertexColumn(const uint04& property, uint04 index, uint04 size);

        void updateVertexColumns(bool invalidate_bounds = true, bool erase_kd_tree = true);

        void updateSolidVertexColumns(bool invalidate_bounds = true, bool erase_kd_tree = true);

        void updateVertexColumns(uint04 index, uint04 size, bool invalidate_bounds = true, bool erase_kd_tree = true);
        
        fltp08 calculateVolume(const Matrix<fltp08>& parent_transform) const;

        fltp08 calculateSurfaceArea(const Matrix<fltp08>& parent_transform) const;

        Vector<2, fltp08> calculateVolumeAndSurfaceArea(const Matrix<fltp08>& transform, const void* lock) const;

        fltp08 calculateLength(const Matrix<fltp08>& transform) const;

        Vector<3, fltp08> calculateAverageDirection(const Matrix<fltp08>& mat) const;

        Vector<2, fltp08> calculateHVLength(const Matrix<fltp08>& mat) const;

        bool hasTree(PrimitiveProperty primitive_property, VertexProperty vertex_property = VertexProperty::Position) const;

        DynamicPointer<RTree<3, fltp04>> tree(PrimitiveProperty primitive_property, VertexProperty vertex_property = VertexProperty::Position) const;

        void setTree(DynamicPointer<RTree<3, fltp04>> tree, PrimitiveProperty primitive_property, VertexProperty vertex_property = VertexProperty::Position) const;

        void removeTrees(VertexProperty vertex_property = VertexProperty::Position);

        void removeTree(PrimitiveProperty property, VertexProperty vertex_property = VertexProperty::Position);

        const Buffer<uint04>& getTreeIndices(PrimitiveProperty primitive_property) const;
        template<class t_type>
        Buffer<t_type> getTreeSortedVertices(PrimitiveProperty primitive_property, VertexProperty vertex_property) const
        {
            const Buffer<uint04>& indices = getTreeIndices(primitive_property);
            Buffer<t_type> original_vals = vertices<t_type>(vertex_property);
            Buffer<t_type> sorted_vertices(indices.size());
            sorted_vertices.setSize(indices.size(), Constant<t_type>::Invalid);
            for(uint04 i = 0; i < indices.size(); ++i)
            {
                if (indices[i] < original_vals.size())
                    sorted_vertices[i] = original_vals[indices[i]];
            }
            return sorted_vertices;
        }

        Ray<3, fltp08> surfaceNormal() const;

        template<class t_type>
        void setVertex(VertexProperty property, uint04 index, const t_type& vector)
        {
            lib_assert(index < vertexCount(), "Out of bounds vertex set");
            column(property).set(vertexOffset() + index, vector);
        }
        
        template<class t_type>
        void setVertex(VertexProperty property, uint04 index, uint04 sub_index, const t_type& vector)
        {
            lib_assert(index < vertexCount(), "Out of bounds vertex set");
            column(property).set(vertexOffset() + index, sub_index, vector);
        }

        template<class t_type>
        void setVertices(VertexProperty property, const Buffer<t_type>& vertices, uint04 offset = 0)
        {
            lib_assert(offset + vertices.size() <= vertexCount(), "Out of bounds vertex set");
            uint04 vertex_offset = vertexOffset() + offset;
            auto& col = column(property);
            for (uint04 i = 0; i < vertices.size(); i++)
            {
                col.set(vertex_offset + i, vertices[i]);
            }
        }

        template<class t_type, class t_matrix_type>
        void setVertices(VertexProperty property, const Buffer<t_type>& vertices, const Matrix<t_matrix_type>& matrix, uint04 offset = 0)
        {
            lib_assert(offset + vertices.size() <= vertexCount(), "Out of bounds vertex set");
            uint04 vertex_offset = vertexOffset() + offset;
            auto& col = column(property);
            for (uint04 i = 0; i < vertices.size(); i++)
            {
                col.set(vertex_offset + i, matrix * vertices[i].template as<t_type::NumberOfDimensions(), t_matrix_type>());
            }
        }

        template<class t_type>
        void setVertices(VertexProperty property, const t_type* vertices, uint04 size, uint04 offset = 0)
        {
            lib_assert(offset + size <= vertexCount(), "Out of bounds vertex set");
            uint04 vertex_offset = vertexOffset() + offset;
            auto& col = column(property);
            for (uint04 i = 0; i < size; i++)
            {
                col.set(vertex_offset + i, vertices[i]);
            }
        }

        template<class t_type>
        decltype(auto) vertex(VertexProperty property, uint04 index) const
        {
            lib_assert(index < vertexCount(), "Out of bounds vertex get");
            return column(property).get<t_type>(vertexOffset() + index);
        }

        template<uint01 t_dims, class t_type>
        LineSegment<t_dims, t_type> lineSegment(PrimitiveProperty primitive_property, VertexProperty vertex_property, uint04 line_index) const
        {
            const Vector<2, uint04> line = primitive<Vector<2, uint04>>(primitive_property, line_index);
            if (IsInvalid(line))
                return Constant<LineSegment<t_dims, t_type>>::Invalid;
            return LineSegment<t_dims, t_type>(
                  vertex<Vector<t_dims, t_type>>(vertex_property, line[A])
                , vertex<Vector<t_dims, t_type>>(vertex_property, line[B]));
        }

        template<uint01 t_dims, class t_type>
        Triangle<t_dims, t_type> triangle(PrimitiveProperty primitive_property, VertexProperty vertex_property, uint04 tri_index) const
        {
            const Vector<3, uint04> tri = primitive<Vector<3, uint04>>(primitive_property, tri_index);
            if (IsInvalid(tri))
                return Constant<Triangle<t_dims, t_type>>::Invalid;
            return Triangle<t_dims, t_type>(
                  vertex<Vector<t_dims, t_type>>(vertex_property, tri[A])
                , vertex<Vector<t_dims, t_type>>(vertex_property, tri[B])
                , vertex<Vector<t_dims, t_type>>(vertex_property, tri[C]));
        }

        bool hasColumn(VertexProperty property) const
        {
            return m_base->vertex_property_column[cast<uint01>(property)] != nullptr;
        }

        template<class t_type>
        Buffer<t_type> propertyVertices(uint04 property) const
        {
            return propertyVertices<t_type>(property, 0, vertexCount());
        }

        template<class t_type>
        Buffer<t_type> propertyVertices(uint04 property, uint04 start, uint04 size) const
        {
            lib_assert(start + size <= vertexCount(), "Out of bounds vertex selection");
            const uint04 vertex_offset = vertexOffset();
            return m_base->vertex_table[property].getAll<t_type>(vertex_offset + start, size);
        }

        template<class t_type>
        Buffer<t_type> vertices(VertexProperty property) const
        {
            return vertices<t_type>(property, 0, vertexCount());
        }

        template<class t_type>
        Buffer<t_type> vertices(VertexProperty property, uint04 start, uint04 size) const
        {
            lib_assert(start + size <= vertexCount(), "Out of bounds vertex selection");
            const uint04 vertex_offset = vertexOffset();
            return column(property).getAll<t_type>(vertex_offset + start, size);
        }

        template<class t_type>
        Buffer<t_type> vertices(const StringView& property) const
        {
            return vertices<t_type>(property, 0, vertexCount());
        }

        template<class t_type>
        Buffer<t_type> vertices(const StringView& property, uint04 start, uint04 size) const
        {
            lib_assert(start + size <= vertexCount(), "Out of bounds vertex selection");
            const uint04 vertex_offset = vertexOffset();
            return propertyColumn(property).getAll<t_type>(vertex_offset + start, size);
        }
        
        template<uint01 t_dims, class t_type>
        Buffer<LineSegment<t_dims, t_type>> lineSegments(PrimitiveProperty primitive_property, VertexProperty vertex_property) const
        {
            uint04 size = primitiveCount(primitive_property);
            switch (mode(primitive_property))
            {
            case PrimitiveMode::e_lines:
                break;
            case PrimitiveMode::e_polyline:
                --size;//polylines have 1 less line segment than number of indices
                break;
            default:
                lib_assert(false, "Bad property fetch mode");
            }
            Buffer<LineSegment<t_dims, t_type>> lines(size);
            for (uint04 i = 0; i < size; ++i)
                lines.add(lineSegment<t_dims, t_type>(primitive_property, vertex_property, i));
            return lines;
        }

        template<uint01 t_dims, class t_type>
        Buffer<Triangle<t_dims, t_type>> triangles(PrimitiveProperty primitive_property, VertexProperty vertex_property) const
        {
            return triangles<t_dims, t_type>(primitive_property, vertex_property, 0, primitiveCount(primitive_property));
        }

        template<uint01 t_dims, class t_type>
        Buffer<Triangle<t_dims, t_type>> triangles(PrimitiveProperty primitive_property, VertexProperty vertex_property, uint04 start, uint04 size) const
        {
            lib_assert(start + size <= primitiveCount(primitive_property), "Out of bounds triangle selection");
            const uint04 index_offset = indexOffset() + indexOffset(primitive_property);
            const PrimitiveMode index_mode = mode(primitive_property);
            const TableColumn& index_column = primitiveColumn();
            const TableColumn& fan_column = primitiveFanColumn();
            const TableColumn& vertex_column = column(vertex_property);
            Buffer<Triangle<t_dims, t_type>> triangles(size);
            
            for (uint04 i = start; i < size + start; i++)
            {
                Vector<3, uint04> index_value;
                switch (index_mode)
                {
                case PrimitiveMode::e_triangle:
                    index_value = {
                          index_column.get<uint04>(index_offset + 3 * i + 0)
                        , index_column.get<uint04>(index_offset + 3 * i + 1)
                        , index_column.get<uint04>(index_offset + 3 * i + 2) };
                    break;
                case PrimitiveMode::e_triangle_strip:
                    index_value = { 
                          index_column.get<uint04>(i + index_offset + 0)
                        , index_column.get<uint04>(i + index_offset + 1)
                        , index_column.get<uint04>(i + index_offset + 2) };
                    break;
                case PrimitiveMode::e_triangle_fan:
                {
                    const uint04 fan_offset = indexFanOffset();
                    uint04 index_fan_location = fan_column.get<uint04>(i + fan_offset);
                    if (IsInvalid(index_fan_location))
                    {
                        index_value = Constant<Vector<3, uint04>>::Invalid;
                    }
                    else
                    {
                        lib_assert(index_fan_location >= index_offset && index_fan_location - index_offset < primitiveCount(primitive_property), "bad fan location");
                        index_value = {
                              index_column.get<uint04>(index_fan_location)
                            , index_column.get<uint04>(i + index_offset - 1)
                            , index_column.get<uint04>(i + index_offset) };
                    }
                } break;
                default:
                    lib_assert(false, "Bad property fetch mode");
                }
                if (IsInvalid(index_value))
                {
                    triangles.add(Constant<Triangle<t_dims, t_type>>::Invalid);
                }
                else
                {
                    triangles.add(Triangle<t_dims, t_type>(
                          vertex_column.get<Vector<t_dims, t_type>>(index_value[A])
                        , vertex_column.get<Vector<t_dims, t_type>>(index_value[B])
                        , vertex_column.get<Vector<t_dims, t_type>>(index_value[C])));
                }
            }
            return triangles;
        }

        Buffer<Buffer<uint04>> polyIndices(PrimitiveProperty primitive_property) const;

        Buffer<Buffer<uint04>> polyIndices(PrimitiveProperty primitive_property, uint04 start, uint04 size) const;
        template<uint01 t_dims, class t_type>
        Buffer<Polygon<t_type, Vertex<t_dims, t_type>>> polygons(PrimitiveProperty primitive_property, VertexProperty vertex_property) const
        {
            return polygons<t_dims, t_type>(primitive_property, vertex_property, 0, primitiveCount(primitive_property));
        }

        template<uint01 t_dims, class t_type>
        Buffer<Polygon<t_type, Vertex<t_dims, t_type>>> polygons(PrimitiveProperty primitive_property, VertexProperty vertex_property, uint04 start, uint04 size) const
        {
            lib_assert(start + size <= primitiveCount(primitive_property), "Out of bounds polygon selection");
            const uint04 index_offset = indexOffset() + indexOffset(primitive_property);
            //const uint04 vertex_offset = vertexOffset();
            const PrimitiveMode index_mode = mode(primitive_property);
            const TableColumn& index_column = primitiveColumn();
            const TableColumn& vertex_column = column(vertex_property);
            Buffer<Polygon<t_type, Vertex<t_dims, t_type>>> polygons(size);
            switch (index_mode)
            {
            case PrimitiveMode::e_triangle:
            case PrimitiveMode::e_triangle_strip:
            case PrimitiveMode::e_triangle_fan:
            {
                const TableColumn& fan_column = primitiveFanColumn();
                const uint04 fan_offset = indexFanOffset();
                for (uint04 i = start; i < size + start; i++)
                {
                    Vector<3, uint04> index_value;
                    switch (index_mode)
                    {
                    case PrimitiveMode::e_triangle:
                        index_value = {
                              index_column.get<uint04>(index_offset + 3 * i + 0)
                            , index_column.get<uint04>(index_offset + 3 * i + 1)
                            , index_column.get<uint04>(index_offset + 3 * i + 2) };
                        break;
                    case PrimitiveMode::e_triangle_strip:
                        index_value = {
                              index_column.get<uint04>(i + index_offset + 0)
                            , index_column.get<uint04>(i + index_offset + 1)
                            , index_column.get<uint04>(i + index_offset + 2) };
                        break;
                    case PrimitiveMode::e_triangle_fan:
                    {
                        uint04 index_fan_location = fan_column.get<uint04>(i + fan_offset);
                        if (IsInvalid(index_fan_location))
                            index_value = Constant<Vector<3, uint04>>::Invalid;
                        else
                            index_value = {
                                  index_column.get<uint04>(index_fan_location)
                                , index_column.get<uint04>(i + index_offset - 1)
                                , index_column.get<uint04>(i + index_offset) };
                    } break;
                    default:
                        lib_assert(false, "Bad property fetch mode");
                    }
                    if (IsValid(index_value))
                    {
                        polygons.add(Polygon<t_type, Vertex<t_dims, t_type>>(3));
                        polygons.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[A]));
                        polygons.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[B]));
                        polygons.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[C]));
 
                    }
                }
            } break;
            case PrimitiveMode::e_polyline:
            {
                Polygon<t_type, Vertex<t_dims, t_type>> poly;
                for (uint04 i = start; i < size + start; i++)
                {
                    uint04 index = index_column.get<uint04>(index_offset + i);
                    if (IsValid(index))
                    {
                        poly.add(vertex_column.get<Vector<t_dims, t_type>>(index));
                    }
                    else
                    {
                        if (poly.vertexCount() > 0)
                        {
                            polygons.add(poly);
                            poly.clear();
                        }
                    }
                }
                if (poly.vertexCount() > 0)
                {
                    polygons.add(poly);
                }
            } break;
            default:
                break;
            }
            return polygons;
        }

        template<uint01 t_dims, class t_type>
        Buffer<Polyline<t_dims, t_type>> polylines(PrimitiveProperty primitive_property, VertexProperty vertex_property) const
        {
            uint04 primitive_count = primitiveCount(primitive_property);
            if(primitive_count == 0)
                return polylines<t_dims, t_type>(primitive_property, vertex_property, 0, vertexCount());
            else
                return polylines<t_dims, t_type>(primitive_property, vertex_property, 0, primitiveCount(primitive_property));
        }

        template<uint01 t_dims, class t_type>
        Buffer<Polyline<t_dims, t_type>> polylines(PrimitiveProperty primitive_property, VertexProperty vertex_property, uint04 start, uint04 size) const
        {
            const uint04 primitive_count = primitiveCount(primitive_property);
            lib_assert(primitive_count == 0 || start + size <= primitive_count, "Out of bounds polyline selection");
            const uint04 index_offset = primitive_count == 0 ? vertexOffset() : indexOffset() + indexOffset(primitive_property);
            const PrimitiveMode index_mode = mode(primitive_property);
            const TableColumn& index_column = primitiveColumn();
            const TableColumn& vertex_column = column(vertex_property);
            Buffer<Polyline<t_dims, t_type>> polylines(size);
            switch (index_mode)
            {
            case PrimitiveMode::e_triangle:
            case PrimitiveMode::e_triangle_strip:
            case PrimitiveMode::e_triangle_fan:
            {
                if (primitive_count == 0)
                    return polylines;//not yet finished
                const TableColumn& fan_column = primitiveFanColumn();
                const uint04 fan_offset = indexFanOffset();
                for (uint04 i = start; i < size + start; i++)
                {
                    Vector<3, uint04> index_value;
                    switch (index_mode)
                    {
                    case PrimitiveMode::e_triangle:
                        index_value = {
                              index_column.get<uint04>(index_offset + 3 * i + 0)
                            , index_column.get<uint04>(index_offset + 3 * i + 1)
                            , index_column.get<uint04>(index_offset + 3 * i + 2) };
                        break;
                    case PrimitiveMode::e_triangle_strip:
                        index_value = {
                              index_column.get<uint04>(i + index_offset + 0)
                            , index_column.get<uint04>(i + index_offset + 1)
                            , index_column.get<uint04>(i + index_offset + 2) };
                        break;
                    case PrimitiveMode::e_triangle_fan:
                    {
                        uint04 index_fan_location = fan_column.get<uint04>(i + fan_offset);
                        if (IsInvalid(index_fan_location))
                            index_value = Constant<Vector<3, uint04>>::Invalid;
                        else
                            index_value = {
                                  index_column.get<uint04>(index_fan_location)
                                , index_column.get<uint04>(i + index_offset - 1)
                                , index_column.get<uint04>(i + index_offset) };
                    } break;
                    default:
                        lib_assert(false, "Bad property fetch mode");
                    }
                    if (IsValid(index_value))
                    {
                        polylines.add(Polyline<t_dims, t_type >(4));
                        polylines.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[A]));
                        polylines.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[B]));
                        polylines.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[C]));
                        polylines.last().add(vertex_column.get<Vector<t_dims, t_type>>(index_value[A]));
 
                    }
                }
            } break;
            case PrimitiveMode::e_polyline:
            {
                Polyline<t_dims, t_type> poly;
                for (uint04 i = start; i < size + start; i++)
                {
                    uint04 index = primitive_count > 0 ? index_column.get<uint04>(index_offset + i) : i + index_offset;
                    Vertex<t_dims, t_type> vert = Constant<Vertex<t_dims, t_type>>::Invalid;
                    if (IsValid(index))
                        vert = vertex_column.get<Vector<t_dims, t_type>>(index);
                    
                    if (IsValid(vert))
                    {
                        poly.add(vert);
                    }
                    else
                    {
                        if (poly.vertexCount() > 0)
                        {
                            polylines.add(poly);
                            poly.clear();
                        }
                    }
                }
                if (poly.vertexCount() > 0)
                {
                    polylines.add(poly);
                }
            } break;
            case PrimitiveMode::e_lines:
            {
                Polyline<t_dims, t_type> poly;
                if (primitive_count == 0)
                    start++;//prevent overflow
                for (uint04 i = start; i < size + start; i++)
                {
                    Vector<2, uint04> index;
                    if (primitive_count == 0)
                    {
                        index = Vector<2, uint04>(i - 1, i) + index_offset;
                        i++;//increment i by one since 
                    }
                    else
                    {
                        index = Vector<2, uint04>(
                              index_column.get<uint04>(index_offset + 2 * i + 0)
                            , index_column.get<uint04>(index_offset + 2 * i + 1));
                    }
                    if (IsValid(index))
                    {
                        Vertex<3, fltp08> vert_a = vertex_column.get<Vector<t_dims, t_type>>(index[A]);
                        if (IsInvalid(vert_a))
                            continue;
                        Vertex<3, fltp08> vert_b = vertex_column.get<Vector<t_dims, t_type>>(index[B]);
                        if (IsInvalid(vert_b))
                            continue;
                        poly.add(vert_a);
                        poly.add(vert_b);
                        polylines.add(poly);
                        poly.clear();
                    }
                }
            } break;
            default:
                break;
            }
            return polylines;
        }

        void setVertexMode(VertexProperty property, VertexMode mode);

        TableColumn& column(VertexProperty property)
        {
            return *m_base->vertex_property_column[cast<uint01>(property)];
        }

        const TableColumn& column(VertexProperty property) const
        {
            return *m_base->vertex_property_column[cast<uint01>(property)];
        }

        const TableVectorType<1, uint01>* vertexFlagColumn() const
        {
            TableColumn* column = m_base->vertex_property_column[eint01(VertexProperty::BitFlag)];
            if (column == nullptr)
                return nullptr;
            return dynamic_cast<TableVectorType<1, uint01>*>(column);
        };

        TableVectorType<1, uint01>* vertexFlagColumn()
        {
            TableColumn* column = m_base->vertex_property_column[eint01(VertexProperty::BitFlag)];
            if (column == nullptr)
                return nullptr;
            return dynamic_cast<TableVectorType<1, uint01>*>(column);
        };
    public:
        TableColumn& propertyColumn(const StringView& property)
        {
            return m_base->vertex_table.get(property);
        }

        const TableColumn& propertyColumn(const StringView& property) const
        {
            return m_base->vertex_table.get(property);
        }


        void setSolidVertexCountValue(uint04 count)
        {
            m_base->solid_vertex_count_column[m_design_index] = count;
        }

        void setSolidVertexReservedValue(uint04 count)
        {
            m_base->solid_vertex_reserved_count_column[m_design_index] = count;
        }

        void setSolidVertexOffsetValue(uint04 count)
        {
            m_base->solid_vertex_offset_column[m_design_index] = count;
        }

        void setupIndexFanColumn();

        uint01 provokingPrimitiveOffset() const;

        void addFromParent(Model& parent);

        void removeParent(Model& parent);
    protected:
        template<class t_index_type, class t_vec_type>
        void setPrimitiveVec(PrimitiveProperty property, uint04 index, t_vec_type& index_value)
        {
            lib_assert(index < primitiveCount(property), "Bad index set");
            if (IsValid(index_value))
            {
#ifdef _DEBUG
                uint04 vertex_count = vertexCount();
                lib_assert(index_value[A] < vertex_count, "Bad vertex A");
                lib_assert(index_value[B] < vertex_count, "Bad vertex B");
                lib_assert(index_value[C] < vertex_count, "Bad vertex C");
#endif
                index_value += t_vec_type(vertexOffset());
            }
            else
            {
                index_value = Constant<t_vec_type>::Invalid;
            }
            OptimizedPrimitiveDef def = optimizedPrimitiveDef(property);
            if (def.mode == PrimitiveMode::e_triangle_fan)
            {
                primitiveFanColumn()[index + indexFanOffset()] = index_value[A];
                (*def.column)[def.index_offset + index - 1] = index_value[B];
                (*def.column)[def.index_offset + index - 0] = index_value[C];
            }
            else
            {
                OptimizedSetPrimitiveVec(def, index, index_value);
            }
        }
        

        void setIndexCountValue(uint04 count)
        {
            m_base->index_mode_size_column[m_design_index] = count;
        }

        void setIndexFanCountValue(uint04 count)
        {
            m_base->index_fan_size_column[m_design_index] = count;
        }

        void setCountValue(PrimitiveProperty property, uint04 count)
        {
            (*m_base->primitive_property_size_column[cast<uint01>(property)])[m_design_index] = count;
        }

        void setIndexFanOffsetValue(uint04 offset)
        {
            m_base->index_fan_offset_column[m_design_index] = offset;
        }

        void setIndexOffsetValue(uint04 offset)
        {
            m_base->index_mode_offset_column[m_design_index] = offset;
        }

        void setOffsetValue(PrimitiveProperty property, uint04 offset)
        {
            (*m_base->primitive_property_offset_column[cast<uint01>(property)])[m_design_index] = offset;
        }

        void setModeValue(PrimitiveProperty property, PrimitiveMode mode)
        {
            m_base->primitive_property_mode_column[cast<uint01>(property)]->set(m_design_index, mode);
        }



        void setVertexCountValue(uint04 count)
        {
            m_base->vertex_count_column[m_design_index] = count;
        }

        void setVertexReservedValue(uint04 count)
        {
            m_base->vertex_reserved_count_column[m_design_index] = count;
        }

        void setVertexOffsetValue(uint04 count)
        {
            m_base->vertex_offset_column[m_design_index] = count;
        }

 
        

        void setModeValue(VertexProperty property, VertexMode vert_mode)
        {
            lib_assert(vert_mode != e_index, "Not yet supported");
            m_base->vertex_mode_column[cast<uint01>(property)]->set(m_design_index, vert_mode);
        }
 
 
    private:
        void reserveVertexSpace(uint04 count, uint04 current_reserve_count);
    protected:
        static std::function<void(Geometry& geo, const Matrix<fltp08>& matrix, const void* lock, LogPtr log)> s_geometry_triangulation; 
    };
    
    template<>
    struct ObjectInfo<Geometry, false, false>
    {
        static const uint01 Dimensions = 0;   
        static const bool Vector = false;      
        static const bool Buffer = false;      
        static const bool Primitive = true;    
        static const bool Pointer = false;     
        static const bool Unsigned = false;    
        static const bool Float = false;       
        static const bool Integer = false;     
        static const bool Number = false;      
        static const bool Enum = false;        
        static const bool String = false;      
        static const bool Color = false;       
        static const bool Boolean = false;     
        static constexpr ObjectInfo<Geometry, false, false> VectorSub() { return ObjectInfo<Geometry, false, false>(); }
    };
    
    class VertexLookup
    {
    public:
        VertexLookup()
            : m_column(nullptr)
            , m_flag_column(nullptr)
            , m_vertex_property(VertexProperty::BitFlag)
            , m_vertex_offset(0)
            , m_vertex_count(0)
        {
        }

        VertexLookup(VertexProperty vertex_property, Geometry geo)
            : m_geo(geo)
            , m_column(&geo.column(vertex_property))
            , m_flag_column(geo.hasVertexProperty(VertexProperty::BitFlag) ? &geo.column(VertexProperty::BitFlag) : nullptr)
            , m_vertex_property(vertex_property)
            , m_vertex_offset(geo.vertexOffset())
            , m_vertex_count(geo.vertexCount())
 
        {}

        VertexLookup(const StringView& vertex_property, Geometry geo)
            : m_geo(geo)
            , m_column(&geo.propertyColumn(vertex_property))
            , m_flag_column(geo.hasVertexProperty(VertexProperty::BitFlag) ? &geo.column(VertexProperty::BitFlag) : nullptr)
            , m_vertex_property(VertexProperty::Invalid)
            , m_vertex_offset(geo.vertexOffset())
            , m_vertex_count(geo.vertexCount())
 
        {}

        template<class t_type>
        t_type get(uint04 index) const
        {
            //const BitFlag flag = m_flag_column.get<uint01>(m_vertex_offset + index);
            //if (flag[cast<uint01>(VertexBitFlags::e_is_hidden)])
                //return Constant<Vertex<t_dims, t_type>>::Invalid;
            return m_column->get<t_type>(m_vertex_offset + index);
        }

        BitFlag flag(uint04 index) const
        {
            BitFlag flag(0);
            if (m_flag_column == nullptr)
                return flag;
            flag = m_flag_column->get<uint01>(m_vertex_offset + index);
            return flag;
        }

        void swap(uint04 a, uint04 b)
        {
            m_column->swap(m_vertex_offset + a, m_vertex_offset + b);
        }

        template<class t_type>
        void setVertex(uint04 index, const t_type& value)
        {
            return m_column->set(m_vertex_offset + index, value);
        }

        void setFlag(uint04 index, const BitFlag& value)
        {
            if (m_flag_column == nullptr)
            {
                if (value == BitFlag(0))
                    return;
                m_geo.ensureFlagColumnExists();
                m_flag_column = &m_geo.column(VertexProperty::BitFlag);
            }
            return m_flag_column->set(m_vertex_offset + index, value);
        }
        
        uint04 size() const
        {
            return m_vertex_count;
        }
        Geometry m_geo;                      
        TableColumn* m_column;               
        TableColumn* m_flag_column;          
        VertexProperty m_vertex_property;    
        uint04 m_vertex_offset;              
        uint04 m_vertex_count;               
    };

    template<class t_type>
    class VertexIterator : public VertexLookup
    {
    public:
        VertexIterator()
        {}

        VertexIterator(VertexProperty vertex_property, Geometry geo)
            : VertexLookup(vertex_property, geo)
        {}

        VertexIterator(const StringView& vertex_property, Geometry geo)
            : VertexLookup(vertex_property, geo)
        {}

        t_type operator[](uint04 index) const
        {
            return get<t_type>(index);
        }
    };

    template<uint01 t_dims, class t_type>
    class LineIterator
    {
    public:
        LineIterator()
            : m_primitive_def(Geometry::OptimizedPrimitiveDef())
            , m_vertex_column(nullptr)
            , m_flag_column(nullptr)
            , m_primitive_count(0)
            , m_vertex_offset(0)
        {}

        LineIterator(PrimitiveProperty primitive_property, VertexProperty vertex_property, Geometry geo)
            : m_vertex_column(&geo.column(vertex_property))
            , m_flag_column(geo.hasVertexProperty(VertexProperty::BitFlag) ? &geo.column(VertexProperty::BitFlag) : nullptr)
            , m_primitive_count(geo.primitiveCount(primitive_property))
            , m_vertex_offset(geo.vertexOffset())
        {
            if (m_primitive_count == 0)
            {
                m_primitive_def.mode = geo.mode(primitive_property);
                switch (m_primitive_def.mode)
                {
                case PrimitiveMode::e_polyline:
                    m_primitive_count = geo.vertexCount();
                    if (m_primitive_count > 0)
                        --m_primitive_count;
                    break;
                case PrimitiveMode::e_lines:
                    m_primitive_count = geo.vertexCount() / 2;
                    break;
                default:
                    lib_assert(false, "Unknown point type");
                    break;
                }
            }
            else
            {
                m_primitive_def = geo.optimizedPrimitiveDef(primitive_property);
                if (m_primitive_count > 0 && m_primitive_def.mode == PrimitiveMode::e_polyline)
                    m_primitive_count--;//since sending vertex count, segment count is one less
            }
        }

        LineIterator(const LineIterator<t_dims, t_type>& iter)
            : m_vertex_property(iter.m_vertex_property)
            , m_primitive_def(iter.m_primitive_def)
            , m_vertex_column(iter.m_vertex_column)
            , m_flag_column(iter.m_flag_column)
            , m_primitive_count(iter.m_primitive_count)
            , m_vertex_offset(iter.m_vertex_offset)
        {
        }
        LineIterator& operator=(const LineIterator& other) = default;

        Vector<2, uint04> vertexIndex(uint04 index) const
        {
            Vector<2, uint04> index_vert = rawIndex(index);
            for (uint01 i = 0; i < 2; i++)
            {
                if (IsInvalid(index_vert[i]))
                    index_vert[i] = Constant<uint04>::Invalid;
                else
                    index_vert[i] -= m_vertex_offset;
            }
            return index_vert;
        }

        template<class t_line_type>
        LineSegment<t_dims, t_line_type> get(uint04 index) const
        {
            Vector<2, uint04> index_vert = rawIndex(index);
            if (IsInvalid(index_vert[0]) || IsInvalid(index_vert[1]) || isHidden(index_vert[0]))
            {
                return Constant<LineSegment<t_dims, t_line_type>>::Invalid;
            }
            LineSegment<t_dims, t_line_type> seg;
            m_vertex_column->get(index_vert[0], seg[0]);
            m_vertex_column->get(index_vert[1], seg[1]);
            return seg;
        }

        LineSegment<t_dims, t_type> operator[](uint04 index) const
        {
            return get<t_type>(index);
        }

        uint04 size() const
        {
            return m_primitive_count;
        }
    protected:
        Vector<2, uint04> rawIndex(uint04 index) const
        {
            if (m_primitive_def.column == nullptr)
                return Vector<2, uint04>(m_vertex_offset + index, m_vertex_offset + index + 1);
            else
                return Geometry::OptimizedGetPrimitiveVec<Vector<2, uint04>>(m_primitive_def, index);
        }

        bool isHidden(uint04 index) const
        {
            if (m_flag_column == nullptr)
                return false;
            BitFlag bit_flags = m_flag_column->get<uint01>(index);
            return bit_flags[cast<uint01>(VertexFlags::e_is_hidden)];
        }
        VertexProperty m_vertex_property;                   
        Geometry::OptimizedPrimitiveDef m_primitive_def;    
        TableColumn* m_vertex_column;                      
        TableColumn* m_flag_column;                        
        uint04 m_primitive_count;                          
        uint04 m_vertex_offset;                            
    };

    template<uint01 t_dims, class t_type>
    class TriangleIterator
    {
    public:
        TriangleIterator()
            : m_vertex_column(nullptr)
            , m_vertex_offset(0)
        {}

        TriangleIterator(PrimitiveProperty primitive_property, VertexProperty vertex_property, Geometry mesh)
            : m_primitive_def(mesh.optimizedPrimitiveDef(primitive_property))
            , m_vertex_column(&mesh.column(vertex_property))
            , m_flag_column(mesh.hasVertexProperty(VertexProperty::BitFlag) ? &mesh.column(VertexProperty::BitFlag) : nullptr)
            , m_primitive_count(mesh.primitiveCount(primitive_property))
            , m_vertex_offset(mesh.vertexOffset())
        {
            if (m_primitive_def.mode == PrimitiveMode::e_triangle_strip)
                m_primitive_count -= 2;//primitive count is vertices so minus 2 triangles
        }

        TriangleIterator(PrimitiveProperty primitive_property, const StringView& vertex_property, Geometry mesh)
            : m_primitive_def(mesh.optimizedPrimitiveDef(primitive_property))
            , m_vertex_column(&mesh.propertyColumn(vertex_property))
            , m_flag_column(mesh.hasVertexProperty(VertexProperty::BitFlag) ? &mesh.column(VertexProperty::BitFlag) : nullptr)
            , m_primitive_count(mesh.primitiveCount(primitive_property))
            , m_vertex_offset(mesh.vertexOffset())
        {
            if (m_primitive_def.mode == PrimitiveMode::e_triangle_strip)
                m_primitive_count -= 2;//primitive count is vertices so minus 2 triangles
        }

        template<class t_tri_type>
        Triangle<t_dims, t_tri_type> get(uint04 index) const
        {
            Vector<3, uint04> index_vert = rawIndex(index);
            Triangle<t_dims, t_tri_type> tri;
            for (uint01 i = 0; i < 3; i++)
            {
                if (IsInvalid(index_vert[i]))
                    tri[i] = Constant<t_tri_type>::Invalid;
                else
                    m_vertex_column->get(index_vert[i], tri[i]);
 
            }
            return tri;
        }

        Triangle<t_dims, t_type> operator[](uint04 index) const
        {
            return get<t_type>(index);
        }

        Vector<3, uint04> vertexIndex(uint04 index) const
        {
            Vector<3, uint04> index_vert = rawIndex(index);
            for (uint01 i = 0; i < 3; i++)
            {
                if (IsValid(index_vert[i]))
                    index_vert[i] -= m_vertex_offset;
            }
            return index_vert;
        }

        Vector<3,BitFlag> flag(uint04 index) const
        {
            Vector<3,BitFlag> flag(BitFlag(0));
            if (m_flag_column == nullptr)
                return flag;
            Vector<3, uint04> index_vert = rawIndex(index);
            for (uint01 i = 0; i < 3; i++)
                flag[i] = m_flag_column->get<uint01>(index_vert[i]);
            return flag;
        }

        uint04 size() const
        {
            return m_primitive_count;
        }
    protected:
        Vector<3, uint04> rawIndex(uint04 index) const
        {
            return Geometry::OptimizedGetPrimitiveVec<Vector<3, uint04>>(m_primitive_def, index);
        }
        Geometry::OptimizedPrimitiveDef m_primitive_def;   
        TableColumn* m_vertex_column;                      
        TableColumn* m_flag_column;                        
        uint04 m_primitive_count;                          
        uint04 m_vertex_offset;                            
    };

    class GeometryPositionModRestore
    {
    public:
        GeometryPositionModRestore()
        {}

        explicit GeometryPositionModRestore(const Geometry& geo)
        {
            store(geo);
        }

        void store(const Geometry& geo);

        void restoreNormals(const void* lock, LogPtr ptr = LogPtr());

        void restoreClosed(const void* lock, LogPtr ptr = LogPtr());

        void restoreAll(const void* lock, LogPtr ptr = LogPtr());

        void restoreSmooth(const void* lock, LogPtr ptr = LogPtr());
 
        bool restore_closed = true;    
        bool restore_normals = true;   
        bool restore_smooth = true;    
    protected:
        void restoreNormals(Geometry& geo, const void* lock, LogPtr ptr = LogPtr());

        void restoreClosed(Geometry& geo, const void* lock, LogPtr ptr = LogPtr());
 
        bool m_has_tangent = false;                              
        bool m_has_bitangent = false;                            
        bool m_is_closed = false;                                
        NormalMode normal_mode = NormalMode::e_no_normals;       
        fltp04 smoothing_angle = Constant<fltp04>::Invalid;      
        String m_smoothing_algo;                                 
        uint04 m_smoothing_times = 0U;                           
        Geometry m_geo;                                          
    };
 
 
    template class NDEVR_DESIGN_API StringStream<NDPG>;
}

namespace std
{
    template <>
    struct hash<Geometry>
    {
        std::size_t operator()(const Geometry& d) const noexcept
        {
            UUID s = d.get<NDPO::guid>();
            std::size_t value = 0;
            for (uint01 i = 0; i < 8; i++)
                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);
            return value;
        }
    };
};
#include <NDEVR/Model.h>
namespace NDEVR
{
    inline Model Geometry::getParent(uint04 index) const
    {
        return Model(m_base->geometry_parent[m_design_index][index], m_base);
    }

    inline uint04 Geometry::parentCount() const
    {
        return m_base->geometry_parent[m_design_index].size();
    }
}