API/_model_8h_source.html

/*--------------------------------------------------------------------------------------------

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;

    class Material;

    class Geometry;

#if NDEVR_SUPPORTS_BONES

    class Bone;

#endif

    class Effect;

    class Log;

    class ProgressInfo;

    template<class t_type>

    class Set;


    /**--------------------------------------------------------------------------------------------------

    \brief A core class that represents a node on model heirarchy. This node may contain a Geometry or

        one or more child Models as well as 3 different materials for rendering the Geometry parts.

    **/


    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_inherited_is_manager_visible = 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 ModelProperty

        {

            e_type

            , e_fixed_bounding_box

            , e_visible_box

            , e_calculation_ignored

            , e_can_select_children

            , e_complete_transform

            , e_material_mode_solid

            , e_material_mode_outline

            , e_material_mode_vertices

            , e_parent_matrix_flags

            , e_global_bounds

            , e_global_selection_bounds

            , e_model_color

            , e_inherited_flags//recursive lookup

            , e_personal_inherited_flags

            , e_export_ignored //do not export this item

            , e_descended_flags//recursive lookup

            , e_personal_descended_flags

            , e_application_constructed

            , e_application_constructed_parent_base

            , e_model_property_size//always last

        };


    public:

        Model(){};

        Model(DesignObjectBase* base);

        Model(uint04 index, DesignObjectBase* base);

        explicit Model(const DesignObject& obj);

        [[nodiscard]] bool isSelected() const;

        [[nodiscard]] bool isApplicationOwned() const;

        [[nodiscard]] bool isVisible() const;

        [[nodiscard]] bool isTreeVisible() const;

        [[nodiscard]] bool hasFocus() const;

        [[nodiscard]] bool exportIgnored() const;

        [[nodiscard]] TranslatedString displayName() const;

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

        template<class t_type>


        void setModelProperty(ModelProperty property, const t_type& value)

        {

            m_base->model_table.get()[m_base->model_property_index[cast<uint04>(property)]].set(m_design_index, value);

        }


        template<class t_type>


        void updateModelProperty(ModelProperty property, const t_type& type, const void* lock_ptr = nullptr)

        {

            if (getModelProperty<t_type>(property) != type)

            {

                WLock wLock(lock_ptr);

                setModelProperty(property, type);

                updateModifiedTime();

            }

        }


        template<class t_type>


        t_type getModelProperty(ModelProperty property) const

        {

            return m_base->model_table.get()[m_base->model_property_index[cast<uint04>(property)]].get<t_type>(m_design_index);

        }


        bool isModelProperty(ModelProperty property, const String& value) const

        {

            return m_base->model_table.get()[m_base->model_property_index[cast<uint04>(property)]].isSame(m_design_index, value);

        }


        bool isModelProperty(ModelProperty property, const char* value) const

        {

            return m_base->model_table.get()[m_base->model_property_index[cast<uint04>(property)]].isSame(m_design_index, value);

        }


        bool doesModelPropertyContain(ModelProperty property, const String& value, bool ignore_case) const

        {

            return propertyTable().get()[m_base->model_property_index[cast<uint04>(property)]].contains(m_design_index, value, ignore_case);

        }


        bool doesModelPropertyContain(ModelProperty property, const char* value, bool ignore_case) const

        {

            return propertyTable().get()[m_base->model_property_index[cast<uint04>(property)]].contains(m_design_index, value, ignore_case);

        }


        void restoreModel();

        void eraseModel();

        void deleteModel(bool delete_children, bool remove_from_parent = true);

        Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> explodeModel();

        [[nodiscard]] bool canExplode() const;

        [[nodiscard]] bool isOfType(const String& type) const;

        [[nodiscard]] bool isOfType(const char* type) const;


        Model createChild();

        Model createChild(uint04 child_slot);

        void createChildren(uint04 child_size);

        Model createSceneModel() const;

        Model createSceneLayer() const;

        Model getSceneModel(UUID id) const;

        Model getSceneLayer(UUID id) const;


        void addChild(Model& child);

        void addChild(uint04 child_index);

        void swapChildren(uint04 a, uint04 b);

        //Parent functions

        void setParentMatrixFlags(BitFlag flags);

        void setParentMatrixFlag(ParentMatrixFlags flag, bool value);

        BitFlag parentMatrixFlags() const;

        Model getParent() const;

        uint04 getParentIndex() const;


        enum class ModelColorMode

        {

            e_direct

            , e_by_selectable_children

            , e_by_material_root

            , e_by_layer

        };


        RGBColor customModelColor(ModelColorMode mode) const;

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

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

        String getModelIcon() const;


        Effect createChildEffect();


        //Geometry functions

        Geometry createChildGeometry();


        void setGeometryChild(uint04 geo_index);

        void setGeometryChild(const Geometry& geo);

        void updateVisible(bool is_visible);

        void updateVisibleRecursive(bool is_visible);

        Buffer<GeometryType> descendentGeometryTypes() const;

        bool hasGeometryDescendent() const;

        bool hasMeshDescendent() const;

        bool hasLinearDescendent() const;

        bool hasPointsDescendent() const;

        void hasDescendents(bool& has_point, bool& has_line, bool& has_mesh) const;


        MaterialMode getMaterialMode(PrimitiveProperty property) const;

        void setMaterialMode(MaterialMode vertex, MaterialMode outline, MaterialMode solid);

        void setMaterialMode(PrimitiveProperty property, MaterialMode option);

        Material createChildMaterial(bool copy_child = false);

        Material createChildMaterial(PrimitiveProperty property, bool copy_child = false);

        void clearMaterialDescendents();

        void overrideMaterialDescendents(PrimitiveProperty property, MaterialMode override_desc);

        void overrideMaterialDescendents(MaterialMode vertex, MaterialMode outline, MaterialMode solid);

        void setMaterial(PrimitiveProperty property, uint04 material_index);

        void setMaterial(uint04 material_index);

        void setMaterial(PrimitiveProperty property, const Material& material);

        void setMaterial(const Material& material);

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

        void checkBounds();


#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

        Effect createSceneEffect() const;


        void setIsLayer(bool is_layer);

        bool isLayer() const;

        bool hasLayer() const;

        [[nodiscard]] bool hasDirectLayer() const;

        [[nodiscard]] Model getLayer() const;

        [[nodiscard]] uint04 getDirectLayerIndex() const;


        //Returns the center of rotation in global units

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


        [[nodiscard]] bool isLocked() const;

        [[nodiscard]] bool canInteract() const;

        [[nodiscard]] bool hasSelectedDescendent() const;

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

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

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

        void setLayer(Model layer);

        void clearLayer();

        [[nodiscard]] uint04 getChildIndex() const;

        [[nodiscard]] uint04 getChildLayerIndex() const;


        void setChildIndex(uint04 child, uint04 id);

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

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

        [[nodiscard]] bool hasChild(uint04 child_index) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getChildren() const;

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

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

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getChildrenByType(const String& type) const;

        template<class t_type>


        [[nodiscard]] Buffer<t_type> getTypeChildren(const String& type) const

        {

            Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> 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]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getChildrenByType(const Buffer<String>& type) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getChildrenByName(const String& name) const;


        template<class t_type>


        [[nodiscard]] Buffer<t_type> getTypeDescendents(const String& type) const

        {

            Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> models = getDescendentsByType(type);

            Buffer<t_type> values(models.size());

            for (uint04 i = 0; i < models.size(); i++)

            {

                values.add(t_type(models[i]));

            }

            return values;

        }


        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getDescendentsByType(const String& type, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getDescendentsByName(const String& name, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getDescendentsByNameAndType(const String& name, const String& type, uint04 max_count = Constant<uint04>::Max) const;


        [[nodiscard]] uint04 childCount() const;

        [[nodiscard]] uint04 getNumOfEffects() const;

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


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


        [[nodiscard]] Geometry getGeometry() const;

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

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

        [[nodiscard]] Buffer<Geometry, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneGeometries() const;

        [[nodiscard]] Buffer<std::pair<Model, Geometry>, uint04, ObjectAllocator<DESIGN_PRIM>> getClippingGeometry() const;

        [[nodiscard]] Buffer<Geometry, uint04, ObjectAllocator<DESIGN_PRIM>> getGeometryDescendents(bool remove_redundant = true, uint04 max_count = Constant<uint04>::Max) const;

        void removeGeometry();


        [[nodiscard]] bool hasMaterial() const;

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

        [[nodiscard]] Material getMaterial(PrimitiveProperty property) const;

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

        [[nodiscard]] Material getRootMaterial(PrimitiveProperty property) const;

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

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

        [[nodiscard]] Buffer<Material, uint04, ObjectAllocator<DESIGN_PRIM>> getMaterialChildren() const;

        [[nodiscard]] Buffer<Material, uint04, ObjectAllocator<DESIGN_PRIM>> getMaterialDescendents(bool local_only = false) const;

        [[nodiscard]] Buffer<Material, uint04, ObjectAllocator<DESIGN_PRIM>> getMaterialDescendents(PrimitiveProperty property) const;

        [[nodiscard]] Buffer<Material, uint04, ObjectAllocator<DESIGN_PRIM>> getMaterialDescendentsByName(const String& name, uint04 max_count = Constant<uint04>::Max) const;

        [[nodiscard]] Buffer<Material, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneMaterials() const;

        void removeMaterial(const Material& material);

        void removeMaterial(PrimitiveProperty property);


        [[nodiscard]] Buffer<Effect, uint04, ObjectAllocator<false>> getEffectChildren() const;

        [[nodiscard]] Buffer<Effect, uint04, ObjectAllocator<false>> getEffectDescendents() const;

        [[nodiscard]] Buffer<Effect, uint04, ObjectAllocator<false>> getSceneEffects() const;

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


        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneModels(bool include_deleted = false, bool local_only = false) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneModelsByType(const String& type, uint04 max_count = Constant<uint04>::Max, bool include_deleted = false) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneModelsByName(const String& name, uint04 max_count = Constant<uint04>::Max, bool include_deleted = false) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getSceneLayers(bool include_deleted = false) const;

        [[nodiscard]] Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> getDescendents(bool include_deleted = false, bool local_only = false) const;


        void clearChildren();

        void removeChild(const Model& model);


        [[nodiscard]] uint04 visibleVertexCount() const;

        [[nodiscard]] uint04 vertexCount() const;


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

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

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


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

        [[nodiscard]] bool hasDescendent(const UUID& id) const;


        void setWindingMode(WindingMode mode);


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

        [[nodiscard]] Matrix<fltp08> getParentTransform() 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;

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

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

        Matrix<fltp08> applyTransformToParent(const Matrix<fltp08>& parent_mat) const;

        //virtual bool processSelection(SelectionInfo& info) const override;

        //Returns the greatest modified time of this + all descendents

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


        //Returns the greatest modified time of this + all parents

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


        //Centers th

        Vertex<3, fltp08> centerAlignModel();

        void calculateIndexNeighborList();

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

        Dictionary<UUID, DesignObject> copyFrom(const Model& model, bool deep_copy, bool copy_ids = false, bool recursive = true);

        Dictionary<UUID, DesignObject> copyMaterialProperties(const Model& model);

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

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

        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 calculateNormals(NormalMode mode, Angle<fltp08> smoothing_angle);

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

        bool isDeleted() const;

        bool hasHoles(PrimitiveProperty property) const;

        void calculateTangentSpace(bool calc_tan, bool calc_bitan);

        void addPerVertexColorFromMaterialConstant(UVType constant_index);

        bool isScene() const;

        void validate(bool validate_children = true) const;

        void invalidateBounds();

        void invalidateVisibleBounds();

        void invalidateGlobalBoundsAsc();

        void invalidateGlobalBoundsDesc();

        void invalidateTransformCache();


        [[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;

        [[nodiscard]] uint04 getGeometryIndex() const;

        [[nodiscard]] uint04 getMaterialIndex(PrimitiveProperty property) const;

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

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

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

        [[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(PrimitiveProperty property);

        [[nodiscard]] BitFlag descendedFlags() const;

        void updateDescendedFlagsCache(bool force_update_all = false);

        [[nodiscard]] BitFlag descendedPersonalFlagsNoCache() const;

        [[nodiscard]] BitFlag personalDescendedFlags() const;

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


        operator bool() const

        {

            return isValid();

        }


        Geometry createSceneGeometry() const;

        Material createSceneMaterial() const;

        static Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>> ReduceToRoots(

              const Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>>& children

            , const std::function<bool(const Model&, const Set<Model>&)>& filter);

    protected:

        uint04 childToParentReference() const;

        uint04 parentToChildReference() const;

        DesignObjectBase* childBase() const;

        DesignObjectBase* parentBase() const;

    private:

        //Returns the greatest modified time of this + all descendents

        Model getRootMaterialModel(PrimitiveProperty property, const Model& value_to_return, bool allow_layer) const;

        Vertex<3, fltp08> _center();

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

        void setChildEffectSize(uint04 child_size);

        void setChildSize(uint04 child_size);

        void setGeometryIndex(uint04 geo_index);

        void setMaterialIndex(PrimitiveProperty property, uint04 material_index);

        void setMaterialIndex(uint04 material_index);

        void setEffectIndex(uint04 material_index, uint04 sub_index = 0);

        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);

    };


    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 = DESIGN_PRIM;

        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>(); }

    };

    //static_assert(!std::is_polymorphic<Model>(), "Model should not be polymorphic");


    /**--------------------------------------------------------------------------------------------------

    \brief The root Model that is responsible for storing the underlying data for all Scene Models.

    **/


    class NDEVR_DESIGN_API Scene : public Model

    {

    public:

        Scene();//Invalid object

        Scene(const TranslatedString& name, DesignObjectBase* base = nullptr);

        Scene(const File& file, DesignObjectBase* base = nullptr);

        Scene(const String& file, DesignObjectBase* base = nullptr) = delete;

        Scene(const TranslatedString& name, Scene& application_scene, DesignObjectBase* base = nullptr);

        Scene(DesignObjectBase* base);


        explicit Scene(const Model& model);


        void createDefaultMaterial();

        bool hasVertexColumn(const String& name) const;

        bool hasVertexColumn(VertexProperty property) const;

        bool hasVertexIndexColumn() const;

        bool isApplicationOwned() const;

        void deleteBase() const;

        Buffer<UUID> allObjectIDs(bool include_deleted) const;

        Scene applicationScene() const;


        TableColumn& vertexColumn(const String& name);

        const TableColumn& vertexColumn(const String& name) const;

        const TableColumn& vertexColumn(VertexProperty property) const;

        const TableColumn& vertexIndexColumn() const;

        static const Scene CreateApplicationScene(const TranslatedString& string);

    };


    template<>

    struct ObjectInfo<Scene, false, false>

    {

        static const uint01 Dimensions = 0;

        static const bool Vector = false;

        static const bool Buffer = false;

        static const bool Primitive = DESIGN_PRIM;

        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<Scene, false, false> VectorSub() { return ObjectInfo<Scene, false, false>(); }

    };

    template<>

    struct NDEVR_DESIGN_API Constant<Model>

    {

        /** The Invalid. */

        static const Model Invalid;

    };


    template class NDEVR_DESIGN_API StringStream<Model::ModelProperty>;

}

namespace std//Define things to allow use within std libs

{

    template <>

    struct hash<NDEVR::Model>

    {

        std::size_t operator()(const NDEVR::Model& d) const noexcept

        {

            NDEVR::UUID s = d.uuid();

            std::size_t value = 0;

            for (NDEVR::uint01 i = 0; i < 8; i++)

                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);

            return value;

        }

    };

    template <>

    struct hash<NDEVR::Scene>

    {

        std::size_t operator()(const NDEVR::Scene& d) const noexcept

        {

            NDEVR::UUID s = d.uuid();

            std::size_t value = 0;

            for (NDEVR::uint01 i = 0; i < 8; i++)

                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);

            return value;

        }

    };

};

NDEVR_DESIGN_API
#define NDEVR_DESIGN_API
Definition DLLInfo.h:55

NDEVR::Angle
The primary angle storage class for this API. Stores an angle in an optimized format.
Definition StringStream.h:540

NDEVR::BitFlag
A bitset that stores 8 bits (elements with only two possible values: 0 or 1, true or false,...
Definition BitFlag.hpp:55

NDEVR::Bounds
A specification of upper and lower bounds in N-dimensions.
Definition Bounds.hpp:52

NDEVR::Buffer
The equivelent of std::vector but with a bit more control. The basic array unit of the library.
Definition Buffer.hpp:56

NDEVR::Buffer::add
void add(t_type &&object)
Adds object to the end of the buffer.
Definition Buffer.hpp:186

NDEVR::Buffer::size
constexpr t_index_type size() const
Definition Buffer.hpp:823

NDEVR::Color
The core Color class in the NDEVR API. Colors can be defined in several ways. The ACIColor is compact...
Definition Color.h:41

NDEVR::DesignObjectBase
Provides the underlying data storage for the NDEVR Scene Model heirarchy.
Definition DesignObjectBase.h:150

NDEVR::DesignObject
A low-level database object that can be used to access general stored properties within the NDEVR Mod...
Definition DesignObject.h:67

NDEVR::Dictionary
A hash-based key-value store, useful for quick associative lookups. Key features include:
Definition Dictionary.h:61

NDEVR::Effect
A core class that provides a dynamic effect to an object in a model heirarchy.
Definition Effect.h:45

NDEVR::File
Logic for reading or writing to a file as well as navigating filesystems.
Definition File.h:48

NDEVR::Geometry
A core class within the model heirarchy containing vertex-based data (Usually 3D data) within a set c...
Definition Geometry.h:64

NDEVR::Material
Container responsible for storing and setting the appearance of a Model or Geometry within the NDEVR ...
Definition Material.h:51

NDEVR::Matrix
Definition Matrix.hpp:176

NDEVR::Model
A core class that represents a node on model heirarchy. This node may contain a Geometry or one or mo...
Definition Model.h:58

NDEVR::Model::descendedFlagsNoCache
BitFlag descendedFlagsNoCache(bool complete_cache_ignore) const

NDEVR::Model::getEffectChildren
Buffer< Effect, uint04, ObjectAllocator< false > > getEffectChildren() const

NDEVR::Model::setGeometryChild
void setGeometryChild(const Geometry &geo)

NDEVR::Model::invalidateVisibleBounds
void invalidateVisibleBounds()

NDEVR::Model::getDescModifiedTime
Time getDescModifiedTime(bool include_self) const

NDEVR::Model::getSceneModelsByType
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneModelsByType(const String &type, uint04 max_count=Constant< uint04 >::Max, bool include_deleted=false) const

NDEVR::Model::invalidateBounds
void invalidateBounds()

NDEVR::Model::calculateLength
fltp08 calculateLength(const Matrix< fltp08 > &transform=Constant< Matrix< fltp08 > >::Invalid) const

NDEVR::Model::clearChildren
void clearChildren()

NDEVR::Model::globalCenterOfRotation
Vertex< 3, fltp08 > globalCenterOfRotation() const

NDEVR::Model::getSceneModel
Model getSceneModel(UUID id) const

NDEVR::Model::getChildIndices
Buffer< uint04 > getChildIndices() const

NDEVR::Model::calculateSmoothTextures
void calculateSmoothTextures(Vector< 3, fltp08 > origin, fltp08 scale)

NDEVR::Model::getCompleteTransform
Matrix< fltp08 > getCompleteTransform() const

NDEVR::Model::restoreModel
void restoreModel()

NDEVR::Model::getSceneLayer
Model getSceneLayer(UUID id) const

NDEVR::Model::eraseModel
void eraseModel()

NDEVR::Model::copyFrom
Dictionary< UUID, DesignObject > copyFrom(const Model &model, bool deep_copy, bool copy_ids=false, bool recursive=true)

NDEVR::Model::getMaterialChildren
Buffer< Material, uint04, ObjectAllocator< DESIGN_PRIM > > getMaterialChildren() const

NDEVR::Model::invalidateTransformCache
void invalidateTransformCache()

NDEVR::Model::doesModelPropertyContain
bool doesModelPropertyContain(ModelProperty property, const char *value, bool ignore_case) const
Definition Model.h:172

NDEVR::Model::size
Vector< 3, fltp08 > size() const

NDEVR::Model::colorByChannel
void colorByChannel(Material &mat, const String &channel, fltp08 avg=Constant< fltp08 >::Invalid) const

NDEVR::Model::hasEffect
bool hasEffect(uint04 index=0) const

NDEVR::Model::getDescendentsByType
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getDescendentsByType(const String &type, uint04 max_count=Constant< uint04 >::Max) const

NDEVR::Model::getDescendentsByName
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getDescendentsByName(const String &name, uint04 max_count=Constant< uint04 >::Max) const

NDEVR::Model::calculateNormals
void calculateNormals(NormalMode mode, Angle< fltp08 > smoothing_angle)

NDEVR::Model::setTransform
void setTransform(const Matrix< fltp08 > &transform)

NDEVR::Model::getTypeDescendents
Buffer< t_type > getTypeDescendents(const String &type) const
Definition Model.h:302

NDEVR::Model::getGeometry
Geometry getGeometry() const

NDEVR::Model::centerAlignModel
Vertex< 3, fltp08 > centerAlignModel()

NDEVR::Model::getParentTransform
Matrix< fltp08 > getParentTransform() const

NDEVR::Model::ModelColorMode
ModelColorMode
Definition Model.h:202

NDEVR::Model::setMaterialMode
void setMaterialMode(MaterialMode vertex, MaterialMode outline, MaterialMode solid)

NDEVR::Model::updateModifiedTime
void updateModifiedTime(Time time=Time::SystemTime())

NDEVR::Model::createChildren
void createChildren(uint04 child_size)

NDEVR::Model::Model
Model(uint04 index, DesignObjectBase *base)

NDEVR::Model::clearMaterialDescendents
void clearMaterialDescendents()

NDEVR::Model::deleteModel
void deleteModel(bool delete_children, bool remove_from_parent=true)

NDEVR::Model::calculateAverageDirection
Vector< 3, fltp08 > calculateAverageDirection(const Matrix< fltp08 > &parent_transform=Constant< Matrix< fltp08 > >::Invalid) const

NDEVR::Model::getMaterialDescendents
Buffer< Material, uint04, ObjectAllocator< DESIGN_PRIM > > getMaterialDescendents(bool local_only=false) const

NDEVR::Model::getMaterial
Material getMaterial(PrimitiveProperty property) const

NDEVR::Model::updateModelProperty
void updateModelProperty(ModelProperty property, const t_type &type, const void *lock_ptr=nullptr)
Definition Model.h:146

NDEVR::Model::getEffectDescendents
Buffer< Effect, uint04, ObjectAllocator< false > > getEffectDescendents() const

NDEVR::Model::globalBounds
Bounds< 3, fltp08 > globalBounds() const

NDEVR::Model::personalInheritedFlags
Vector< 32, bool > personalInheritedFlags() const

NDEVR::Model::Model
Model()
Definition Model.h:128

NDEVR::Model::doesModelPropertyContain
bool doesModelPropertyContain(ModelProperty property, const String &value, bool ignore_case) const
Definition Model.h:168

NDEVR::Model::setParentMatrixFlag
void setParentMatrixFlag(ParentMatrixFlags flag, bool value)

NDEVR::Model::updateFrom
void updateFrom(const Model &model, bool check_resources)

NDEVR::Model::getMaterialDescendentsByName
Buffer< Material, uint04, ObjectAllocator< DESIGN_PRIM > > getMaterialDescendentsByName(const String &name, uint04 max_count=Constant< uint04 >::Max) const

NDEVR::Model::updateDescendedFlagsCache
void updateDescendedFlagsCache(bool force_update_all=false)

NDEVR::Model::createSceneMaterial
Material createSceneMaterial() const

NDEVR::Model::calculateTangentSpace
void calculateTangentSpace(bool calc_tan, bool calc_bitan)

NDEVR::Model::hasDescendents
void hasDescendents(bool &has_point, bool &has_line, bool &has_mesh) const

NDEVR::Model::getSceneMaterial
Material getSceneMaterial(UUID id) const

NDEVR::Model::childBase
DesignObjectBase * childBase() const

NDEVR::Model::getDirectLayerIndex
uint04 getDirectLayerIndex() const

NDEVR::Model::displayNamePath
TranslatedString displayNamePath(const String &seperator=":") const

NDEVR::Model::overrideMaterialDescendents
void overrideMaterialDescendents(PrimitiveProperty property, MaterialMode override_desc)

NDEVR::Model::invalidateGlobalBoundsDesc
void invalidateGlobalBoundsDesc()

NDEVR::Model::isLocked
bool isLocked() const

NDEVR::Model::hasMeshDescendent
bool hasMeshDescendent() const

NDEVR::Model::explodeModel
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > explodeModel()

NDEVR::Model::getEffectIndex
uint04 getEffectIndex(uint04 child_index=0) const

NDEVR::Model::MaterialMode
MaterialMode
Definition Model.h:61

NDEVR::Model::createSceneEffect
Effect createSceneEffect() const

NDEVR::Model::canInteract
bool canInteract() const

NDEVR::Model::createSceneGeometry
Geometry createSceneGeometry() const

NDEVR::Model::invalidateGlobalBoundsAsc
void invalidateGlobalBoundsAsc()

NDEVR::Model::isModelProperty
bool isModelProperty(ModelProperty property, const String &value) const
Definition Model.h:160

NDEVR::Model::getChildrenByName
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getChildrenByName(const String &name) const

NDEVR::Model::isSelected
bool isSelected() const

NDEVR::Model::hasGeometryDescendent
bool hasGeometryDescendent() const

NDEVR::Model::descendentGeometryTypes
Buffer< GeometryType > descendentGeometryTypes() const

NDEVR::Model::getChild
Model getChild(uint04 child) const

NDEVR::Model::hasChild
bool hasChild(uint04 child_index) const

NDEVR::Model::Model
Model(const DesignObject &obj)

NDEVR::Model::vertexCount
uint04 vertexCount() const

NDEVR::Model::getChildIndex
uint04 getChildIndex() const

NDEVR::Model::inheritedPersonalFlagsNoCache
Vector< 32, bool > inheritedPersonalFlagsNoCache() const

NDEVR::Model::removeDuplicateVertices
void removeDuplicateVertices(fltp08 epsilon, void *lock, ProgressInfo *log=nullptr)

NDEVR::Model::hasFocus
bool hasFocus() const

NDEVR::Model::getMaterialDescendents
Buffer< Material, uint04, ObjectAllocator< DESIGN_PRIM > > getMaterialDescendents(PrimitiveProperty property) const

NDEVR::Model::Model
Model(DesignObjectBase *base)

NDEVR::Model::getGeometryIndex
uint04 getGeometryIndex() const

NDEVR::Model::canExplode
bool canExplode() const

NDEVR::Model::removeMaterial
void removeMaterial(PrimitiveProperty property)

NDEVR::Model::setMaterial
void setMaterial(const Material &material)

NDEVR::Model::getNumOfEffects
uint04 getNumOfEffects() const

NDEVR::Model::getMaterialIndex
uint04 getMaterialIndex(PrimitiveProperty property) const

NDEVR::Model::parentToChildReference
uint04 parentToChildReference() const

NDEVR::Model::hasDirectLayer
bool hasDirectLayer() const

NDEVR::Model::setNormalMode
void setNormalMode(NormalMode mode, Angle< fltp08 > smoothing_angle, ProgressInfo *log)

NDEVR::Model::getModelIcon
String getModelIcon() const

NDEVR::Model::getSceneModelsByName
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneModelsByName(const String &name, uint04 max_count=Constant< uint04 >::Max, bool include_deleted=false) const

NDEVR::Model::visibleVertexCount
uint04 visibleVertexCount() const

NDEVR::Model::hasLayer
bool hasLayer() const

NDEVR::Model::getClippingGeometry
Buffer< std::pair< Model, Geometry >, uint04, ObjectAllocator< DESIGN_PRIM > > getClippingGeometry() const

NDEVR::Model::parentMatrixFlags
BitFlag parentMatrixFlags() const

NDEVR::Model::getAscModifiedTime
Time getAscModifiedTime(bool include_self, bool include_layer=true) const

NDEVR::Model::addChild
void addChild(Model &child)

NDEVR::Model::personalDescendedFlags
BitFlag personalDescendedFlags() const

NDEVR::Model::childToParentReference
uint04 childToParentReference() const

NDEVR::Model::setChildIndex
void setChildIndex(uint04 child, uint04 id)

NDEVR::Model::updateInheritedFlagsCache
void updateInheritedFlagsCache(bool force_update_all=false, bool update_personal_flags=false)

NDEVR::Model::DescendedFlags
DescendedFlags
Definition Model.h:96

NDEVR::Model::isModelProperty
bool isModelProperty(ModelProperty property, const char *value) const
Definition Model.h:164

NDEVR::Model::getSceneModels
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneModels(bool include_deleted=false, bool local_only=false) const

NDEVR::Model::createChild
Model createChild()

NDEVR::Model::calculateSurfaceArea
fltp08 calculateSurfaceArea(const Matrix< fltp08 > &transform=Constant< Matrix< fltp08 > >::Invalid) const

NDEVR::Model::inheritedFlags
Vector< 32, bool > inheritedFlags() const

NDEVR::Model::isOfType
bool isOfType(const char *type) const

NDEVR::Model::getParent
Model getParent() const

NDEVR::Model::hasPointsDescendent
bool hasPointsDescendent() const

NDEVR::Model::getBounds
Bounds< 3, fltp08 > getBounds() const

NDEVR::Model::createChildEffect
Effect createChildEffect()

NDEVR::Model::calculateHVLength
Vector< 2, fltp08 > calculateHVLength(const Matrix< fltp08 > &parent_transform=Constant< Matrix< fltp08 > >::Invalid) const

NDEVR::Model::removeChild
void removeChild(const Model &model)

NDEVR::Model::getDescendents
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getDescendents(bool include_deleted=false, bool local_only=false) const

NDEVR::Model::getSceneEffect
Effect getSceneEffect(UUID id) const

NDEVR::Model::getEffect
Effect getEffect(uint04 index=0) const

NDEVR::Model::findDescendentByName
Model findDescendentByName(const String &name) const

NDEVR::Model::setWindingMode
void setWindingMode(WindingMode mode)

NDEVR::Model::createChild
Model createChild(uint04 child_slot)

NDEVR::Model::removeGeometry
void removeGeometry()

NDEVR::Model::createChildMaterial
Material createChildMaterial(bool copy_child=false)

NDEVR::Model::calculateVolumeAndSurfaceArea
Vector< 2, fltp08 > calculateVolumeAndSurfaceArea(const Matrix< fltp08 > &transform=Constant< Matrix< fltp08 > >::Invalid, const void *lock=nullptr) const

NDEVR::Model::addChild
void addChild(uint04 child_index)

NDEVR::Model::hasMaterial
bool hasMaterial(PrimitiveProperty property) const

NDEVR::Model::validate
void validate(bool validate_children=true) const

NDEVR::Model::addPerVertexColorFromMaterialConstant
void addPerVertexColorFromMaterialConstant(UVType constant_index)

NDEVR::Model::getParentIndex
uint04 getParentIndex() const

NDEVR::Model::getSelectionBounds
Bounds< 3, fltp08 > getSelectionBounds() const

NDEVR::Model::getDescendentsByNameAndType
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getDescendentsByNameAndType(const String &name, const String &type, uint04 max_count=Constant< uint04 >::Max) const

NDEVR::Model::InheritedFlags
InheritedFlags
Definition Model.h:80

NDEVR::Model::isVisible
bool isVisible() const

NDEVR::Model::setGeometryChild
void setGeometryChild(uint04 geo_index)

NDEVR::Model::findDescendentByType
Model findDescendentByType(const String &type) const

NDEVR::Model::getLayer
Model getLayer() const

NDEVR::Model::calculateIndexNeighborList
void calculateIndexNeighborList()

NDEVR::Model::getChildrenByType
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getChildrenByType(const String &type) const

NDEVR::Model::calculateVolume
fltp08 calculateVolume(const Matrix< fltp08 > &transform=Constant< Matrix< fltp08 > >::Invalid) const

NDEVR::Model::descendedFlags
BitFlag descendedFlags() const

NDEVR::Model::globalSelectionBounds
Bounds< 3, fltp08 > globalSelectionBounds() const

NDEVR::Model::getSceneGeometries
Buffer< Geometry, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneGeometries() const

NDEVR::Model::setParentMatrixFlags
void setParentMatrixFlags(BitFlag flags)

NDEVR::Model::customModelColor
RGBColor customModelColor(ModelColorMode mode) const

NDEVR::Model::isTreeVisible
bool isTreeVisible() const

NDEVR::Model::getChildren
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getChildren() const

NDEVR::Model::setMaterial
void setMaterial(PrimitiveProperty property, const Material &material)

NDEVR::Model::checkBounds
void checkBounds()

NDEVR::Model::getSceneGeometry
Geometry getSceneGeometry(uint04 index) const

NDEVR::Model::setMaterial
void setMaterial(uint04 material_index)

NDEVR::Model::getTypeChildren
Buffer< t_type > getTypeChildren(const String &type) const
Definition Model.h:288

NDEVR::Model::descendedPersonalFlagsNoCache
BitFlag descendedPersonalFlagsNoCache() const

NDEVR::Model::isApplicationOwned
bool isApplicationOwned() const

NDEVR::Model::hasLayerRootMaterial
bool hasLayerRootMaterial(PrimitiveProperty property) const

NDEVR::Model::hasHoles
bool hasHoles(PrimitiveProperty property) const

NDEVR::Model::setIsLayer
void setIsLayer(bool is_layer)

NDEVR::Model::overrideMaterialDescendents
void overrideMaterialDescendents(MaterialMode vertex, MaterialMode outline, MaterialMode solid)

NDEVR::Model::exportIgnored
bool exportIgnored() const

NDEVR::Model::isLayer
bool isLayer() const

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

NDEVR::Model::getGeometryDescendents
Buffer< Geometry, uint04, ObjectAllocator< DESIGN_PRIM > > getGeometryDescendents(bool remove_redundant=true, uint04 max_count=Constant< uint04 >::Max) const

NDEVR::Model::hasDescendent
bool hasDescendent(const UUID &id) const

NDEVR::Model::isDeleted
bool isDeleted() const

NDEVR::Model::setModelProperty
void setModelProperty(ModelProperty property, const t_type &value)
Definition Model.h:141

NDEVR::Model::getFamilyMember
Model getFamilyMember(uint04 index) const

NDEVR::Model::parentBase
DesignObjectBase * parentBase() const

NDEVR::Model::createChildGeometry
Geometry createChildGeometry()

NDEVR::Model::getSceneLayers
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneLayers(bool include_deleted=false) const

NDEVR::Model::hasSelectedDescendent
bool hasSelectedDescendent() const

NDEVR::Model::childCount
uint04 childCount() const

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

NDEVR::Model::hasMaterial
bool hasMaterial() const

NDEVR::Model::updateTransform
void updateTransform(const Matrix< fltp08 > &transform, const void *lock=nullptr)

NDEVR::Model::getRootMaterial
Material getRootMaterial(PrimitiveProperty property) const

NDEVR::Model::getSceneMaterials
Buffer< Material, uint04, ObjectAllocator< DESIGN_PRIM > > getSceneMaterials() const

NDEVR::Model::ReduceToRoots
static Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > ReduceToRoots(const Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > &children, const std::function< bool(const Model &, const Set< Model > &)> &filter)

NDEVR::Model::applyTransformToParent
Matrix< fltp08 > applyTransformToParent(const Matrix< fltp08 > &parent_mat) const

NDEVR::Model::createSceneModel
Model createSceneModel() const

NDEVR::Model::getModelProperty
t_type getModelProperty(ModelProperty property) const
Definition Model.h:156

NDEVR::Model::isOfType
bool isOfType(const String &type) const

NDEVR::Model::swapChildren
void swapChildren(uint04 a, uint04 b)

NDEVR::Model::setSize
void setSize(const Vector< 3, fltp08 > &size)

NDEVR::Model::updateVisibleRecursive
void updateVisibleRecursive(bool is_visible)

NDEVR::Model::setMaterialMode
void setMaterialMode(PrimitiveProperty property, MaterialMode option)

NDEVR::Model::getSceneGeometry
Geometry getSceneGeometry(UUID id) const

NDEVR::Model::updateDescTime
void updateDescTime(const Time &time, bool include_self)

NDEVR::Model::getRootMaterialModel
Model getRootMaterialModel(PrimitiveProperty property)

NDEVR::Model::setMaterial
void setMaterial(PrimitiveProperty property, uint04 material_index)

NDEVR::Model::isScene
bool isScene() const

NDEVR::Model::getBoundsOfVisible
Bounds< 3, fltp08 > getBoundsOfVisible() const

NDEVR::Model::getSceneEffects
Buffer< Effect, uint04, ObjectAllocator< false > > getSceneEffects() const

NDEVR::Model::updateAscTime
void updateAscTime(const Time &time, bool include_self)

NDEVR::Model::getChildrenIDs
Buffer< UUID > getChildrenIDs() const

NDEVR::Model::ParentMatrixFlags
ParentMatrixFlags
Definition Model.h:68

NDEVR::Model::hasLinearDescendent
bool hasLinearDescendent() const

NDEVR::Model::getChildLayerIndex
uint04 getChildLayerIndex() const

NDEVR::Model::getSceneMaterial
Material getSceneMaterial(uint04 index) const

NDEVR::Model::ModelProperty
ModelProperty
Definition Model.h:103

NDEVR::Model::getMaterialMode
MaterialMode getMaterialMode(PrimitiveProperty property) const

NDEVR::Model::updateVisible
void updateVisible(bool is_visible)

NDEVR::Model::getChildIndex
uint04 getChildIndex(uint04 child) const

NDEVR::Model::hasDescendent
bool hasDescendent(const Model &model) const

NDEVR::Model::copyMaterialProperties
Dictionary< UUID, DesignObject > copyMaterialProperties(const Model &model)

NDEVR::Model::setLayer
void setLayer(Model layer)

NDEVR::Model::removeMaterial
void removeMaterial(const Material &material)

NDEVR::Model::displayName
TranslatedString displayName() const

NDEVR::Model::clearLayer
void clearLayer()

NDEVR::Model::getChildrenByType
Buffer< Model, uint04, ObjectAllocator< DESIGN_PRIM > > getChildrenByType(const Buffer< String > &type) const

NDEVR::Model::inheritedFlagsNoCache
Vector< 32, bool > inheritedFlagsNoCache(bool complete_cache_ignore) const

NDEVR::Model::createSceneLayer
Model createSceneLayer() const

NDEVR::Model::createChildMaterial
Material createChildMaterial(PrimitiveProperty property, bool copy_child=false)

NDEVR::ObjectAllocator
Definition MemoryManager.h:261

NDEVR::Pointer
Provides shared ownership of a dynamically allocated object.
Definition Pointer.hpp:71

NDEVR::ProgressInfo
A light-weight base class for Log that allows processes to update, without the need for additional in...
Definition ProgressInfo.hpp:48

NDEVR::RGBColor
Represents a color in the RGB space with optional alpha transparency.
Definition RGBColor.h:54

NDEVR::Scene
The root Model that is responsible for storing the underlying data for all Scene Models.
Definition Model.h:492

NDEVR::Scene::hasVertexColumn
bool hasVertexColumn(const String &name) const

NDEVR::Scene::Scene
Scene(const TranslatedString &name, Scene &application_scene, DesignObjectBase *base=nullptr)

NDEVR::Scene::Scene
Scene(const Model &model)

NDEVR::Scene::hasVertexIndexColumn
bool hasVertexIndexColumn() const

NDEVR::Scene::createDefaultMaterial
void createDefaultMaterial()

NDEVR::Scene::vertexColumn
const TableColumn & vertexColumn(const String &name) const

NDEVR::Scene::vertexColumn
TableColumn & vertexColumn(const String &name)

NDEVR::Scene::Scene
Scene(const String &file, DesignObjectBase *base=nullptr)=delete

NDEVR::Scene::CreateApplicationScene
static const Scene CreateApplicationScene(const TranslatedString &string)

NDEVR::Scene::Scene
Scene(const File &file, DesignObjectBase *base=nullptr)

NDEVR::Scene::Scene
Scene(const TranslatedString &name, DesignObjectBase *base=nullptr)

NDEVR::Scene::deleteBase
void deleteBase() const

NDEVR::Scene::vertexColumn
const TableColumn & vertexColumn(VertexProperty property) const

NDEVR::Scene::Scene
Scene()

NDEVR::Scene::isApplicationOwned
bool isApplicationOwned() const

NDEVR::Scene::hasVertexColumn
bool hasVertexColumn(VertexProperty property) const

NDEVR::Scene::allObjectIDs
Buffer< UUID > allObjectIDs(bool include_deleted) const

NDEVR::Scene::Scene
Scene(DesignObjectBase *base)

NDEVR::Scene::applicationScene
Scene applicationScene() const

NDEVR::Scene::vertexIndexColumn
const TableColumn & vertexIndexColumn() const

NDEVR::Set
Container that stores unique elements in no particular order, and which allow for fast retrieval or i...
Definition Model.h:51

NDEVR::String
The core String class for the NDEVR API.
Definition String.h:69

NDEVR::TableColumn
A virtual storage type that is used with Table class to store data where the actual mechanism for sto...
Definition TableColumn.h:76

NDEVR::Time
Represents a timestamp with utilities for manipulation and conversion.
Definition Time.h:54

NDEVR::TranslatedString
Any text displayed to the user should be defined as a TranslatedString which allows the program to lo...
Definition TranslatedString.h:13

NDEVR::UUID
A universally unique identifier (UUID) is a 128-bit number used to identify information in computer s...
Definition UUID.h:60

NDEVR::Vector
A fixed-size array with better performance compared to dynamic containers.
Definition Vector.hpp:60

NDEVR::Vertex
A vertex or point. A specific type of Vector used primarily for spacial location information.
Definition Vertex.hpp:48

NDEVR::WLock
Used to lock a particular variable for writing. Only one write lock can be created when no read locks...
Definition RWLock.h:115

NDEVR
Definition ACIColor.h:37

NDEVR::NormalMode
NormalMode
Definition DesignObjectBase.h:105

NDEVR::VertexProperty
VertexProperty
Definition DesignObjectBase.h:52

NDEVR::VertexProperty::Invalid
@ Invalid

NDEVR::e_by_layer
@ e_by_layer
Definition CADEntities.h:48

NDEVR::DESIGN_PRIM
constexpr bool DESIGN_PRIM
Definition DesignObject.h:47

NDEVR::PrimitiveProperty
PrimitiveProperty
Definition DesignObjectBase.h:44

NDEVR::uint01
uint8_t uint01
-Defines an alias representing a 1 byte, unsigned integer -Can represent exact integer values 0 throu...
Definition BaseValues.hpp:80

NDEVR::e_type
@ e_type
Definition ModuleResourceManager.h:56

NDEVR::WindingMode
WindingMode
Definition DesignObjectBase.h:97

NDEVR::uint04
uint32_t uint04
-Defines an alias representing a 4 byte, unsigned integer -Can represent exact integer values 0 throu...
Definition BaseValues.hpp:96

NDEVR::fltp08
double fltp08
Defines an alias representing an 8 byte floating-point number.
Definition BaseValues.hpp:149

NDEVR::UVType
UVType
Channels that describe how an object should interact with light.
Definition DesignObjectBase.h:133

std
Definition File.h:211

NDEVR::Constant
Defines for a given type (such as sint04, fltp08, UUID, etc) a maximum, minimum, and reserved 'invali...
Definition BaseValues.hpp:233

NDEVR::ObjectInfo
Information about the object.
Definition ObjectInfo.h:54