Model.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: Model
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/DesignObject.h>
namespace NDEVR
{
    enum class UVType;
    enum class PrimitiveProperty;
    enum class WindingMode;
    class Scene;
    class Database;
    class File;
#if NDEVR_SUPPORTS_BONES
    class Bone;
#endif
    class Log;
    class InfoPipe;
    template<class t_type>
    class Set;
    enum class NDPN
    {
        type                       
        , fixed_bounding_box       
        , visible_box              
        , calculation_ignored      
        , can_select_children      
        , complete_transform       
        , material_mode            
        , parent_matrix_flags      
        , global_bounds            
        , global_selection_bounds  
        , model_color              
        , inherited_flags          
        , personal_inherited_flags 
        , export_ignored           
        , child_base_ptr           
        , parent_base_ptr          
        , material_base_ptr        
        , geometry_base_ptr        
        , model_property_size      
    };

    template<> struct PropertySpec<NDPN::type> { using type = StringView; };
    template<> struct PropertySpec<NDPN::fixed_bounding_box> { using type = Bounds<3, fltp08>; };
    template<> struct PropertySpec<NDPN::visible_box> { using type = Bounds<3, fltp08>; };
    template<> struct PropertySpec<NDPN::calculation_ignored> { using type = bool; };
    template<> struct PropertySpec<NDPN::can_select_children> { using type = bool; };
    template<> struct PropertySpec<NDPN::complete_transform> { using type = Matrix<fltp08>; };
    template<> struct PropertySpec<NDPN::material_mode> { using type = uint01; };
    template<> struct PropertySpec<NDPN::parent_matrix_flags> { using type = BitFlag; };
    template<> struct PropertySpec<NDPN::global_bounds> { using type = Bounds<3, fltp08>; };
    template<> struct PropertySpec<NDPN::global_selection_bounds> { using type = Bounds<3, fltp08>; };
    template<> struct PropertySpec<NDPN::model_color> { using type = RGBColor; };
    template<> struct PropertySpec<NDPN::inherited_flags> { using type = Vector<32, bool>; };
    template<> struct PropertySpec<NDPN::personal_inherited_flags> { using type = Vector<32, bool>; };
    template<> struct PropertySpec<NDPN::export_ignored> { using type = bool; };
    template<> struct PropertySpec<NDPN::child_base_ptr> { using type = DesignObjectBase*; };
    template<> struct PropertySpec<NDPN::parent_base_ptr> { using type = DesignObjectBase*; };
    template<> struct PropertySpec<NDPN::material_base_ptr> { using type = DesignObjectBase*; };
    template<> struct PropertySpec<NDPN::geometry_base_ptr> { using type = DesignObjectBase*; };

    template<>
    class PropertyInterface<NDPN>
    {
    public:
        template<class t_valutype>
        static decltype(auto) Get(const DesignInfo* object, NDPN property)
        {
            return column(object, property)->get<t_valutype>(object->m_design_index);
        }

        template<NDPN t_property, class t_valutype>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return column(object, t_property)->get<t_valutype>(object->m_design_index);
        }

        template<class t_valutype>
        static void Set(DesignInfo* object, NDPN property, const t_valutype& value)
        {
            column(object, property)->set(object->m_design_index, value);
        }

        template<NDPN t_property, class t_valutype>
        static inline void Set(DesignInfo* object, const t_valutype& value)
        {
            if constexpr (t_property == NDPN::type)
                object->m_base->model_type[object->m_design_index] = value;
            else if constexpr (t_property == NDPN::visible_box)
                object->m_base->visible_box[object->m_design_index] = rcast<Vector<6, fltp08>>(value);
            else if constexpr (t_property == NDPN::global_bounds)
                object->m_base->global_bounds[object->m_design_index] = rcast<Vector<6, fltp08>>(value);
            else if constexpr (t_property == NDPN::global_selection_bounds)
                object->m_base->global_selection_bounds[object->m_design_index] = rcast<Vector<6, fltp08>>(value);
            else if constexpr (t_property == NDPN::complete_transform)
                object->m_base->complete_transform[object->m_design_index] = rcast<Vector<16, fltp08>>(value);
            else if constexpr (t_property == NDPN::child_base_ptr)
                object->m_base->child_base_ptr[object->m_design_index] = (uint08)value;
            else if constexpr (t_property == NDPN::parent_base_ptr)
                object->m_base->parent_base_ptr[object->m_design_index] = (uint08)value;
            else if constexpr (t_property == NDPN::material_base_ptr)
                object->m_base->material_base_ptr[object->m_design_index] = (uint08)value;
            else if constexpr (t_property == NDPN::geometry_base_ptr)
                object->m_base->geometry_base_ptr[object->m_design_index] = (uint08)value;
            else if constexpr (t_property == NDPN::inherited_flags)
                object->m_base->inherited_flags[object->m_design_index] = rcast<uint04>(value);
            else if constexpr (t_property == NDPN::personal_inherited_flags)
                object->m_base->personal_inherited_flags[object->m_design_index] = rcast<uint04>(value);
            else
                column(object, t_property)->set(object->m_design_index, value);
        }

        static constexpr TableColumn* column(const DesignInfo* object, NDPN property)
        {
            return object->m_base->model_properties[eint01(property)];
        }

        static bool IsSame(const DesignInfo* object, NDPN property, const StringView& value)
        {
            return column(object, property)->isSame(object->m_design_index, value);
        }

        template<NDPN t_property>
        static decltype(auto) Get(const DesignInfo* object)
        {
            if constexpr (t_property == NDPN::type)
                return object->m_base->model_type[object->m_design_index];
            else if constexpr (t_property == NDPN::visible_box)
                return *reinterpret_cast<Bounds<3, fltp08>*>(&object->m_base->visible_box[object->m_design_index]);
            else if constexpr (t_property == NDPN::global_bounds)
                return *reinterpret_cast<Bounds<3, fltp08>*>(&object->m_base->global_bounds[object->m_design_index]);
            else if constexpr (t_property == NDPN::global_selection_bounds)
                return *reinterpret_cast<Bounds<3, fltp08>*>(&object->m_base->global_selection_bounds[object->m_design_index]);
            else if constexpr (t_property == NDPN::complete_transform)
                return *reinterpret_cast<Matrix<fltp08>*>(&object->m_base->complete_transform[object->m_design_index]);
            else if constexpr (t_property == NDPN::child_base_ptr)
                return object->m_base->child_base_ptr[object->m_design_index];
            else if constexpr (t_property == NDPN::parent_base_ptr)
                return object->m_base->parent_base_ptr[object->m_design_index];
            else if constexpr (t_property == NDPN::inherited_flags)
                return *reinterpret_cast<Vector<32, bool>*>(&object->m_base->inherited_flags[object->m_design_index]);
            else if constexpr (t_property == NDPN::personal_inherited_flags)
                return *reinterpret_cast<Vector<32, bool>*>(&object->m_base->personal_inherited_flags[object->m_design_index]);
            else if constexpr (t_property == NDPN::material_base_ptr)
                return object->m_base->material_base_ptr[object->m_design_index];
            else if constexpr (t_property == NDPN::geometry_base_ptr)
                return object->m_base->geometry_base_ptr[object->m_design_index];
            else
                return column(object, t_property)->get<typename PropertySpec<t_property>::type>(object->m_design_index);
        }
    };

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

        static constexpr uint04 index(const DesignInfo* object, NDPN)
        {
            return object->m_design_index;
        }
    };

    class NDEVR_DESIGN_API Model : public DesignObject
    {
    public:
        enum class MaterialMode
        {
              e_by_parent  
            , e_by_layer   
            , e_custom     
            , e_hidden     
        };

        enum ParentMatrixFlags : uint01
        {
              e_ignore_offset = 0            
            , e_ignore_scale = 1             
            , e_ignore_rotation = 2          
            , e_ignore_scale_distortion = 3  
            , e_use_only_for_offset = 4      
            , e_orient_to_camera = 5         
            , e_follow_camera = 6            
            , e_scale_to_camera = 7          
        };

        enum InheritedFlags : uint01
        {
              e_inherited_is_visible = 0                     
            , e_inherited_has_no_focus = 1                   
            , e_inherited_is_tree_visible = 2                
            , e_inherited_not_selected = 3                   
            , e_placholder = 4                               
            , e_inherited_can_delete = 5                     
            , e_inherited_does_not_follow_camera = 6         
            , e_inherited_does_not_orient_to_camera = 7      
            , e_inherited_does_not_scale_to_camera = 8       
            , e_inherited_not_deleted = 9                    
            , e_inherited_not_application_owned = 10         
            , e_inherited_exportable = 11                    
        };

        enum DescendedFlags
        {
              e_descendent_selected = 0          
            , e_descendent_focussed = 1          
            , e_descendent_deletion_blocked = 2  
        };

        enum class ModelColorMode
        {
              e_direct                 
            , e_by_selectable_children 
            , e_by_material_root       
            , e_by_layer               
        };
    public:
        Model(){};

        Model(DesignObjectBase* base);

        Model(uint04 index, DesignObjectBase* base);

        explicit Model(const DesignInfo& obj);

        void restoreModel();

        void restoreModel(Model& parent, uint04 index = Constant<uint04>::Invalid);

        void eraseModel();

        void deleteModel(bool deletchildren, bool removfrom_parent = true);

        [[nodiscard]] bool isSelected() const;

        [[nodiscard]] bool isApplicationOwned() const;

        [[nodiscard]] bool isLocked() const;

        [[nodiscard]] bool canInteract() const;

        [[nodiscard]] bool hasSelectedDescendent() const;

        [[nodiscard]] bool isVisible() const;

        [[nodiscard]] bool isTreeVisible() const;

        [[nodiscard]] bool hasFocus() const;

        [[nodiscard]] bool exportIgnored() const;

        [[nodiscard]] bool canExplode() const;

        [[nodiscard]] bool isDeleted() const;

        [[nodiscard]] bool isScene() const;

        [[nodiscard]] TranslatedString displayName() const;

        [[nodiscard]] TranslatedString displayNamePath(const StringView& seperator = ":") const;

        bool setModelVisible(bool is_visible);

        template<class t_type>
 
        [[nodiscard]] bool doesModelPropertyContain(NDPN property, const StringView& value, bool ignorcase) const
        {
            return m_base->model_properties[eint01(property)]->contains(m_design_index, value, ignorcase);
        }

        [[nodiscard]] bool doesModelPropertyContain(NDPN property, const char* value, bool ignorcase) const
        {
            return m_base->model_properties[eint01(property)]->contains(m_design_index, value, ignorcase);
        }

        ModelBuffer explodeModel();

        template<class t_buffer_type>
        [[nodiscard]] bool isType(const Buffer<t_buffer_type>& types) const
        {
            for (const t_buffer_type& iter : types)
            {
                if (is<NDPN::type>(iter))
                    return true;
            }
            return false;
        }

        void updateFrom(const Model& model, bool check_resources);

        void copyFrom(const Model& model, bool deep_copy, bool copy_ids = false, bool recursive = true, bool keep_root_properties = false);

        void updateModelTransform(const Matrix<fltp08>& transform, const void* lock = nullptr);

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

        void updateVisibleRecursive(bool is_visible);

        [[nodiscard]] RGBColor customModelColor(ModelColorMode mode) const;

        [[nodiscard]] StringView getModelIcon() const;

        [[nodiscard]] Vertex<3, fltp08> globalCenterOfRotation() const;

        [[nodiscard]] Bounds<3, fltp08> getBounds() const;

        [[nodiscard]] Bounds<3, fltp08> globalBounds() const;

        [[nodiscard]] Bounds<3, fltp08> globalSelectionBounds() const;

        [[nodiscard]] Bounds<3, fltp08> getBoundsOfVisible() const;

        [[nodiscard]] Bounds<3, fltp08> getSelectionBounds() const;

        void checkBounds();

        Vertex<3, fltp08> centerAlignModel();

        [[nodiscard]] Vector<3, fltp08> size() const;

        void setSize(const Vector<3, fltp08>& size);
 
        //-------- Children --------

        Model createChild();

        Model createChild(uint04 child_slot);

        void createChildren(uint04 child_size);

        Model createSceneModel() const;

        Model getSceneModel(UUID id) const;

        void addChild(Model& child);

        void addChild(uint04 child_idx, Model& child);

        void addChild(uint04 child_index);

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

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

        void setChildIndex(uint04 child, uint04 id);

        void updateAscTime(const Time& time, bool includself);

        void updateAscGeometryTime(const Time& time, bool include_self);

        void updateDescTime(const Time& time, bool include_self);

        void updateDescGeometryTime(const Time& time, bool include_self);

        [[nodiscard]] Model getChild(uint04 child) const;

        [[nodiscard]] uint04 getChildIndex(uint04 child) const;

        [[nodiscard]] bool hasChild(uint04 child_index = 0U) const;

        [[nodiscard]] ModelBuffer getChildren() const;

        void getChildren(ModelBuffer& children) const;

        [[nodiscard]] Model getChild(UUID id) const;

        [[nodiscard]] Buffer<UUID> getChildrenIDs() const;

        [[nodiscard]] Buffer<uint04> getChildIndices() const;

        [[nodiscard]] ModelBuffer getChildrenByType(const StringView& type) const;

        [[nodiscard]] ModelBuffer getChildrenByType(const Buffer<String>& type) const;

        template<class t_type>
        [[nodiscard]] Buffer<t_type> getTypeChildren(const StringView& type) const
        {
            ModelBuffer models = getChildrenByType(type);
            Buffer<t_type> values(models.size());
            for (uint04 i = 0; i < models.size(); i++)
            {
                values.add(t_type(models[i]));
            }
            return values;
        }

        [[nodiscard]] ModelBuffer getChildrenByName(const StringView& name) const;

        [[nodiscard]] ModelBuffer getDescendantsByType(const StringView& type, uint04 max_count = Constant<uint04>::Max) const;

        template<class t_type>
        [[nodiscard]] Buffer<t_type> getTypeDescendants(const StringView& type) const
        {
            auto models = getDescendantsByType(type);
            Buffer<t_type> values(models.size());
            for (uint04 i = 0; i < models.size(); i++)
            {
                values.add(t_type(models[i]));
            }
            return values;
        }

        [[nodiscard]] ModelBuffer getDescendantsByName(const StringView& name, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] ModelBuffer getDescendantsByNameAndType(const StringView& name, const StringView& type, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] uint04 childCount() const;

        void swapChildren(uint04 a, uint04 b);

        [[nodiscard]] ModelBuffer getSceneModels(bool include_deleted = false, bool local_only = false) const;

        [[nodiscard]] ModelBuffer getSceneModelsByType(const StringView& type, uint04 max_count = Constant<uint04>::Max, bool includdeleted = false) const;

        [[nodiscard]] ModelBuffer getSceneModelsByName(const StringView& name, uint04 max_count = Constant<uint04>::Max, bool includdeleted = false) const;

        [[nodiscard]] ModelBuffer getDescendants(bool include_deleted = false, bool local_only = false) const;

        void getDescendants(ModelBuffer& buffer, bool include_deleted = false, bool local_only = false) const;

        void clearChildren();

        void deleteChildren();

        void removeChild(const Model& model);

        [[nodiscard]] Model getFamilyMember(uint04 index) const;

        [[nodiscard]] Model findDescendentByName(const StringView& name) const;

        [[nodiscard]] Model findDescendentByType(const StringView& type) const;

        [[nodiscard]] bool hasDescendent(const Model& model) const;

        [[nodiscard]] bool hasDescendent(const UUID& id) const;
 
        //-------- Parent functions --------

        void setParentMatrixFlags(BitFlag flags);

        void setParentMatrixFlag(ParentMatrixFlags flag, bool value);

        [[nodiscard]] BitFlag parentMatrixFlags() const;

        [[nodiscard]] Model getParent() const;

        [[nodiscard]] Model getRoot() const;

        [[nodiscard]] uint04 getParentIndex() const;

        void setChildApplicationConstructed(DesignObjectBase* base);

        void setChildApplicationConstructed(const StringView& database_name = StringView());

        void setGeometryApplicationConstructed(const StringView& database_name = StringView());

        void setMaterialApplicationConstructed(const StringView& database_name = StringView());

        void ensureVisibleChildren(uint04 count);
 
        //-------- Effect --------

        [[nodiscard]] EffectBuffer getEffectChildren() const;

        [[nodiscard]] EffectBuffer getEffectDescendants() const;

        [[nodiscard]] EffectBuffer getSceneEffects() const;

        [[nodiscard]] Effect getEffect(uint04 index = 0) const;

        [[nodiscard]] Effect createSceneEffect() const;

        Effect createChildEffect();

        [[nodiscard]] uint04 getNumOfEffects() const;

        [[nodiscard]] bool hasEffect(uint04 index = 0) const;

        [[nodiscard]] Effect getSceneEffect(UUID id) const;

        [[nodiscard]] uint04 getEffectIndex(uint04 child_index = 0) const;

        void setChildEffectSize(uint04 child_size);

        void setEffectIndex(uint04 material_index, uint04 sub_index = 0);
 
        //-------- Layer Logic --------

        [[nodiscard]] ModelBuffer getSceneLayers(bool include_deleted = false) const;

        void setLayer(Model layer);

        void setIsLayer(bool is_layer);

        void clearLayer();

        [[nodiscard]] bool isLayer() const;

        [[nodiscard]] bool hasLayer() const;

        [[nodiscard]] bool hasDirectLayer() const;

        [[nodiscard]] Model getLayer() const;

        [[nodiscard]] uint04 getDirectLayerIndex() const;

        [[nodiscard]] Model directLayer() const;

        [[nodiscard]] uint04 getChildIndex() const;

        [[nodiscard]] uint04 getChildLayerIndex() const;

        [[nodiscard]] Model createSceneLayer() const;

        [[nodiscard]] Model getSceneLayer(UUID id) const;
 
        //-------- Geometry --------

        void setGeometryIndex(uint04 geo_index);

        [[nodiscard]] uint04 getGeometryIndex() const;

        void setGeometryChild(Geometry& geo);

        [[nodiscard]] Geometry createChildGeometry();

        [[nodiscard]] Geometry getGeometry() const;

        [[nodiscard]] Geometry getSceneGeometry(uint04 index) const;

        [[nodiscard]] Geometry getSceneGeometry(UUID id) const;

        [[nodiscard]] GeometryBuffer getSceneGeometries() const;

        [[nodiscard]] PrimitiveAlignedBuffer<std::pair<Model, Geometry>, 32> getClippingGeometry() const;

        [[nodiscard]] GeometryBuffer getGeometryDescendants(bool remove_redundant = true, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] Geometry createSceneGeometry() const;

        [[nodiscard]] bool hasGeometryDescendent() const;

        [[nodiscard]] bool hasMeshDescendent() const;

        [[nodiscard]] bool hasLinearDescendent() const;

        [[nodiscard]] bool hasPointsDescendent() const;

        void calculateIndexNeighborList();

        void hasDescendants(bool& has_point, bool& has_line, bool& has_mesh, bool only_user_objects) const;

        void removeGeometry();

        void descendentGeometryTypes(Set<GeometryType>& buffer) const;

        void calculateNormals(NormalMode mode, Angle<fltp08> smoothing_angle);

        void removeDuplicateVertices(fltp08 epsilon, void* lock, InfoPipe* log = nullptr);

        void setWindingMode(WindingMode mode);

        [[nodiscard]] uint04 visibleVertexCount() const;

        [[nodiscard]] uint04 vertexCount() const;

        [[nodiscard]] bool hasHoles(PrimitiveProperty property) const;

        void ensureTangentSpace(bool ensure_tan, bool ensure_bitan);

        void calculateTangentSpace(bool calc_tan, bool calc_bitan);

        void calculateSmoothTextures(Vector<3, fltp08> origin, fltp08 scale);

        void setNormalMode(NormalMode mode, Angle<fltp08> smoothing_angle, InfoPipe* log);

        void addPerVertexColorFromMaterialConstant(UVType constant_index);

        [[nodiscard]] fltp08 calculateVolume(const Matrix<fltp08>& transform = Constant<Matrix<fltp08>>::Invalid) const;

        [[nodiscard]] fltp08 calculateSurfaceArea(const Matrix<fltp08>& transform = Constant<Matrix<fltp08>>::Invalid) const;

        [[nodiscard]] Vector<2, fltp08> calculateVolumeAndSurfaceArea(const Matrix<fltp08>& transform = Constant<Matrix<fltp08>>::Invalid, const void* lock = nullptr) const;

        [[nodiscard]] fltp08 calculateLength(const Matrix<fltp08>& transform = Constant<Matrix<fltp08>>::Invalid) const;

        [[nodiscard]] Vector<3, fltp08> calculateAverageDirection(const Matrix<fltp08>& parent_transform = Constant<Matrix<fltp08>>::Invalid) const;

        [[nodiscard]] Vector<2, fltp08> calculateHVLength(const Matrix<fltp08>& parent_transform = Constant<Matrix<fltp08>>::Invalid) const;
 
        //-------- Material --------

        [[nodiscard]] MaterialMode getMaterialMode() const;

        [[nodiscard]] Material createChildMaterial(bool copy_child = false);

        [[nodiscard]] bool hasMaterial() const;

        [[nodiscard]] Material getMaterial() const;

        [[nodiscard]] uint04 getMaterialIdx() const;

        [[nodiscard]] Material getSceneMaterial(uint04 index) const;

        [[nodiscard]] Material getRootMaterial() const;

        [[nodiscard]] bool hasRootMaterial() const;

        [[nodiscard]] Material getSceneMaterial(UUID id) const;

        [[nodiscard]] bool hasLayerRootMaterial() const;

        [[nodiscard]] Material createSceneMaterial() const;

        [[nodiscard]] MaterialBuffer getMaterialDescendants(bool local_only = false) const;

        void getMaterialDescendants(MaterialBuffer& materials, bool local_only = false) const;

        void getMaterialDescendants(Set<Material>& materials, bool local_only = false) const;

        [[nodiscard]] MaterialBuffer getMaterialDescendantsByName(const StringView& name, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] MaterialBuffer getSceneMaterials() const;

        void setMaterialMode(MaterialMode option);

        void clearMaterialDescendants();

        void clearMaterial();

        void overrideMaterialDescendants(MaterialMode override_desc);

        void setMaterial(const Material& material);

        void colorByChannel(Material& mat, const StringView& channel, fltp08 avg = Constant<fltp08>::Invalid) const;

        void removeMaterial();

        void copyMaterialProperties(const Model& model);
 
#if NDEVR_SUPPORTS_BONES
        Bone createSceneBone() const;

        bool hasBone(uint04 index = 0) const;

        uint04 getNumOfBones() const;

        Bone getBone(uint04 index = 0) const;

        Bone getSceneBone(UUID id) const;

        Buffer<Bone, uint04, ObjectAllocator<false>> getBones() const;

        Matrix<fltp08> getBoneTransform(uint04 index = 0) const;

        uint04 getBoneGroupIndex(uint04 child_index = 0) const;

        void setBoneGroupIndex(uint04 bone_group_index, uint04 sub_index = 0);
#endif

        [[nodiscard]] Matrix<fltp08> getCompleteTransform() const;

        [[nodiscard]] Matrix<fltp08> getParentTransform() const;

        [[nodiscard]] Matrix<fltp08> applyTransformToParent(Matrix<fltp08> mat, const Matrix<fltp08>& parent_mat) const;

        [[nodiscard]] Time getDescModifiedTime(bool includself) const;

        [[nodiscard]] Time getAscModifiedTime(bool include_self, bool include_layer = true) const;

        void validate(bool validate_children = true) const;

        void setOrientation(const Vector<3, Angle<sint04>>& new_orientation, const void* lock = nullptr);

        void setOrientation(const Vector<3, Angle<fltp08>>& new_orientation, const void* lock = nullptr);

        void updateInheritedFlagsCache(bool force_update_all = false, bool update_personal_flags = false);

        void invalidateBounds();

        void invalidateSelectionBounds();

        void invalidateVisibleBounds();

        void invalidateGlobalBoundsDesc();

        void invalidateTransformCache();

        [[nodiscard]] Vector<32, bool> inheritedFlags() const;

        [[nodiscard]] Vector<32, bool> inheritedPersonalFlagsNoCache() const;

        [[nodiscard]] Vector<32, bool> personalInheritedFlags() const;

        [[nodiscard]] Vector<32, bool> inheritedFlagsNoCache(bool complete_cache_ignore) const;

        [[nodiscard]] Model getRootMaterialModel();

        [[nodiscard]] BitFlag descendedPersonalFlagsNoCache() const;

        [[nodiscard]] BitFlag personalDescendedFlags() const;

        [[nodiscard]] BitFlag descendedFlagsNoCache(bool complete_cache_ignore) const;

        operator bool() const
        {
            return isValid();
        }

        static ModelBuffer ReduceToRoots(
              const ModelBuffer& children
            , const std::function<bool(const Model&, const Set<Model>&)>& filter);
    protected:
        ColumnT<uint04>& childToParentReference() const;

        ColumnT<Buffer<uint04>>& parentToChildReference() const;

        DesignObjectBase* materialBase() const;

        DesignObjectBase* geometryBase() const;

        DesignObjectBase* childBase() const;

        DesignObjectBase* parentBase() const;
    private:
        Model getRootMaterialModel(const Model& value_to_return, bool allow_layer) const;

        Vertex<3, fltp08> _center();

        Bounds<3, fltp08> _bounds(bool usselection_bounds, bool get_global) const;

        void setChildSize(uint04 child_size);

        void setMaterialIndex(uint04 material_index);

        void setPersonalInheritedFlags(const Vector<32, bool>& flags);

        void setPersonalInheritedFlag(InheritedFlags flag, bool value);

        void _copyFrom(const Model& model, bool deep_copy, bool copy_ids, bool recursive_copy, Dictionary<UUID, DesignObject>& copy_to_index, bool is_root_copy, bool keep_root_properties);
    };

    template<>
    struct ObjectInfo<Model, 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<Model, false, false> VectorSub() { return ObjectInfo<Model, false, false>(); }
    };
#ifndef _DEBUG
    static_assert(!std::is_polymorphic<Model>(), "Model should not be polymorphic");
    static_assert(std::is_trivially_destructible<Model>(), "Model should not be polymorphic");
#endif

    template<>
    struct NDEVR_DESIGN_API Constant<Model>
    {
        static const Model Invalid; 
    };

    template class NDEVR_DESIGN_API StringStream<NDPN>;
    template class NDEVR_DESIGN_API StringStream<Model::MaterialMode>;
}
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<Model>
    {
        std::size_t operator()(const Model& 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;
        }
    };
};