DesignObject.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: DesignObject
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObjectBase.h>
#include <NDEVR/RWLock.h>
#include <NDEVR/TranslatedString.h>
namespace NDEVR
{
    class DesignCommand;
    class File;
    class Scene;
    class JSONNode;
    class SelectionInfo;
#ifdef _DEBUG
    constexpr bool DESIGN_PRIM = false;
#else
    constexpr bool DESIGN_PRIM = true;
#endif
    /**--------------------------------------------------------------------------------------------------
    \brief A low-level database object that can be used to access general stored properties within the NDEVR
        Model heirarchy or 3D environment.
    
    Can represent a geometry, model, material, bone, or effect. The object itself can be thought of
        as pointer to an entity in the database, and in general its destruction, will have no impact on the database
        itself. 
 
    This object stores a pointer to a DesignObjectBase object which is the database containing all properties
        which are retrieved via an index (for general properties) or a design index, for properties specific to
        models, geometries, etc
    \warning Access to these members and data should be made in a thread-safe manner using DesignObjectLookup 
        read and write locks.
    Author: Tyler Parke
 
    Date: 2018-03-22
    **/
    class NDEVR_DESIGN_API DesignObject
    {
    public:
        /**--------------------------------------------------------------------------------------------------
        Enum representing the type of object a design object could be. A design object can be checked for
            inheritance using the isDesignType function.
        **/
        enum DesignObjectType
        {
              e_model     = 0x00000001
            , e_geometry  = 0x00000002
            , e_material  = 0x00000004
            , e_bone      = 0x00000008
            , e_effect    = 0x00000010
            , e_layer     = 0x00000020
            , e_scene     = 0x00000040
            , e_camera    = 0x00000080
            , e_selection = 0x00000100
        };
        /**--------------------------------------------------------------------------------------------------
        \brief Values stored in the property database. 
        
        A specific value can be retrieved using the getProperty command
            or set via the setPropertyCommand. Upon changing the value, at some point, updateDesignModifiedTime 
            should be called to notify the application about the changes to the design object.
        **/
        enum DesignProperty
        {
              e_guid // A 128 bit globally unique identifier for the object.
            , e_design_types // The location of the bitflag storing what type of obect this is
            , e_transform // A 4x4 transform that describes how to translate any coordinates into global space
            , e_bounding_box
            , e_selection_box
            , e_name // The name of the object
            , e_description // The Description of the object
            , e_editable_description // Whether or not the user is allowed to modify the description of the object
            , e_creation_time
            , e_modified_time
            , e_asc_modified_time
            , e_desc_modified_time
            , e_bounds_modified_time
            , e_author
            , e_creation_software
            , e_3D_visible
            , e_tree_visible
            , e_icon
            , e_is_selected
            , e_is_focused
            , e_allow_interactions
            , e_file
            , e_search_terms
            , e_category
            , e_deletion_allowed
            , e_is_deleted
            , e_is_application_locked
            , e_is_application_owned
            , e_bounds_ignored
            , e_selection_ignored
            , e_meta_data
            , e_untranslated_string_data
            , e_translated_string_data
            , e_uncompressed_data
            , e_compressed_data
            , e_manager_visible
            , e_library_id
            , e_is_frozen
            , e_applied_filters
            //////////////////
            , e_design_property_size//always last
        };
 
        /**--------------------------------------------------------------------------------------------------
        \brief Creates an "invalid" design object. This object does not have a backing database, and all indices will
            be Invalid. Checking properties on this object is not permitted but you may use the '=' to set this model
            to a different model.
 
        Author: Tyler Parke
 
        Date: 2018-03-22
        **/
        DesignObject() = default;
 
        /**--------------------------------------------------------------------------------------------------
        \brief Creates an new design object within the given DesignObjectBase. This object is appended to the end
            of the DesignObjectBase data structure and values are setup to defaults.
 
        Author: Tyler Parke
 
        Date: 2018-03-22
        **/
        explicit DesignObject(DesignObjectBase* base);
 
        /**--------------------------------------------------------------------------------------------------
        \brief Sets a DesignObject up to be a pointer to an existing object in the database. If the index is invalid
            behavior is undefined.
 
        Author: Tyler Parke
 
        Date: 2018-03-22
        **/
        DesignObject(uint04 index, DesignObjectBase* base);
#ifdef _DEBUG
        ~DesignObject();
#endif
        void setDesignType(DesignObjectType mode, bool is_type);
        bool isDesignType(DesignObjectType mode) const;
        bool isDesignType(uint04 mode) const;
        bool validateDesignObject() const;
        JSONNode activeFilters() const;
        void setActiveFilters(const JSONNode& node);
        template<class t_type>
        void setProperty(DesignProperty property, const t_type& value)
        {
            propertyTable().get()[m_base->property_index[cast<uint04>(property)]].set(index(), value);
            switch (property)
            {
            case e_guid:
                m_uuid = getProperty<UUID>(property);
                break;
            case e_bounding_box:
                //lib_assert((getProperty<Bounds<3, fltp08>>(property) != Constant<Bounds<3, fltp08>>::Min), "Tried to set min bounding box");
                break;
#ifdef _DEBUG
            case e_transform:
            {
                Matrix<fltp08> mat = getProperty<Matrix<fltp08>>(property);
                lib_assert(!IsInvalid(mat), "Tried to set Invalid transform");
                lib_assert(!IsInvalid(mat.invert()), "Tried to set to non-invertable transform");
            } break;
            case e_name:
                debug_name = getProperty<String>(property);
                break;
#endif
            default:
                break;
            }
        }
        template<>
        void setProperty(DesignProperty property, const UUID& value)
        {
            propertyTable().get()[m_base->property_index[cast<uint04>(property)]].set(index(), value);
            switch (property)
            {
            case e_guid:
                m_uuid = value;
                break;
            default:
                break;
            }
        }
        template<>
        void setProperty(DesignProperty property, const String& value)
        {
            switch (property)
            {
            case e_name:
                onNameChange(value);
                break;
            default:
                break;
            }
            propertyTable().get()[m_base->property_index[cast<uint04>(property)]].set(index(), value);
        }
        File file() const;
        /*template<>
        void setProperty(DesignProperty property, const TranslatedString& value)
        {
            switch (property)
            {
            case e_name:
                onNameChange(value.translation());
                break;
            default:
                break;
            }
            propertyTable().get()[m_base->property_index[cast<uint04>(property)]].set(index(), value);
        }*/
        template<class t_type>
        void updateProperty(DesignProperty property, const t_type& value, const void* lock = nullptr)
        {
            if (getProperty<t_type>(property) != value)
            {
                WLock wLock(lock);
                setProperty(property, value);
                updateDesignModifiedTime();
            }
        }
        //Scene getScene() const;
 
        template<class t_type>
        [[nodiscard]] t_type getProperty(DesignProperty property) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].get<t_type>(index());
        }
 
        template<class t_type>
        [[nodiscard]] bool hasProperty(DesignProperty property) const
        {
            return !IsInvalid(getProperty<t_type>(property));
        }
        [[nodiscard]] bool isProperty(DesignProperty property, const String& value) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].isSame(index(), value);
        }
        [[nodiscard]] bool isProperty(DesignProperty property, const char* value) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].isSame(index(), value);
        }
        [[nodiscard]] bool doesPropertyBeginWith(DesignProperty property, const String& value, bool ignore_case) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].beginsWith(index(), value, ignore_case);
        }
        [[nodiscard]] bool doesPropertyBeginWith(DesignProperty property, const char* value, bool ignore_case) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].beginsWith(index(), value, ignore_case);
        }
        [[nodiscard]] bool doesPropertyContain(DesignProperty property, const String& value, bool ignore_case) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].contains(index(), value, ignore_case);
        }
        [[nodiscard]] bool doesPropertyContain(DesignProperty property, const char* value, bool ignore_case) const
        {
            return propertyTable().get()[m_base->property_index[cast<uint04>(property)]].contains(index(), value, ignore_case);
        }
        template<class t_type>
        [[nodiscard]] t_type getInheritedProperty(DesignProperty property) const
        {
            if (hasProperty<t_type>(property))
                return getProperty<t_type>(property);
            uint04 parent_index = getDesignParentIndex();
            while (!IsInvalid(parent_index))
            {
                DesignObject parent(parent_index, m_base);
                if (parent.hasProperty<t_type>(property))
                    return parent.getProperty<t_type>(property);
                else
                    parent_index = parent.getDesignParentIndex();
            }
            return getProperty<t_type>(property);
        }
 
        //virtual bool processSelection(SelectionInfo& info) const;
        [[nodiscard]] String getIcon() const;
        
        [[nodiscard]] uint04 getDesignParentIndex() const;
 
        [[nodiscard]] Time getModifiedTime() const;
 
        void updateDesignModifiedTime(Time time = Time::SystemTime());
        void updateCreatedTime();
        void copyFrom(const DesignObject& object);
        //Adjusts this model's index based on models being deleted from the specified index
        void actionDeletedIndex(uint04 index, uint04 size);
        void addIndex(uint04 index, uint04 size);
        void scale(Vector<3, fltp08> scale, Vertex<3, fltp08> center_of_scale = Constant<Vertex<3, fltp08>>::Invalid);
        void offset(const Vector<3, fltp08>& offset);
        bool hasMetaData(const String& index) const;
        [[nodiscard]] const JSONNode& metaData(const String& index) const;
        [[nodiscard]] const JSONNode& metaData() const;
        void setMetaData(const JSONNode& node);
        void setMetaData(const String& index, const JSONNode& node);
        void setMetaData(const String& index, const String& data);
        void setMetaData(const String& index, const bool& data);
        void setMetaData(const String& index, const fltp08& data);
        void setMetaData(const String& index, const uint04& data);
        void clearMetaData(const String& index);
        void updateMetaData(const String& index, const String& data, const void* lock_ptr = nullptr);
        void updateMetaData(const String& index, const fltp08& data, const void* lock_ptr = nullptr);
        void updateMetaData(const String& index, const bool& data, const void* lock_ptr = nullptr);
        void removeMetaData(const String& index, const void* lock_ptr = nullptr);
        void appendData(const String& data, bool compressed);
        inline uint04 index() const { return m_index; }
        inline uint04 designIndex() const { return m_design_index; }
        [[nodiscard]] const DynamicPointer<Table>& propertyTable() const;
        [[nodiscard]] DynamicPointer<Table>& propertyTable();
        bool operator==(const DesignObject& model) const;
        bool operator!=(const DesignObject& model) const;
        bool operator<(const DesignObject& model) const;
        bool operator>(const DesignObject& model) const;
        operator bool() const
        {
            return isValid();
        }
        [[nodiscard]] DesignObjectBase& base() const { return *m_base; }
        [[nodiscard]] UUID uuid() const;
        void updateDesignTransform(const Matrix<fltp08>& transform, const void* lock = nullptr);
        void setDesignVisible(bool is_visible);
        void updateDesignVisible(bool is_visible, const void* lock = nullptr);
        [[nodiscard]] Matrix<fltp08> getTransform() const;
        [[nodiscard]] bool isValid() const { return !IsInvalid(m_index); }
        [[nodiscard]] Scene getScene() const;
        [[nodiscard]] static constexpr const char* FilePathDesignNameVariable() { return "[DESIGN_NAME]"; }
 
    protected:
        void onNameChange(const String& new_name);
    protected:
        mutable UUID m_uuid = Constant<UUID>::Invalid;
        uint04 m_index = Constant<uint04>::Invalid;
        uint04 m_design_index = Constant<uint04>::Invalid;
        DesignObjectBase* m_base = nullptr; 
#ifdef _DEBUG
        String debug_name;
#endif
    };
    template class NDEVR_DESIGN_API StringStream<DesignObject::DesignProperty>;
    //static_assert(!std::is_polymorphic<DesignObject>(), "Model should not be polymorphic");
    template<>
    struct ObjectInfo<DesignObject, 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<DesignObject, false, false> VectorSub() { return ObjectInfo<DesignObject, false, false>(); }
    };
}
 
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<NDEVR::DesignObject>
    {
        std::size_t operator()(const NDEVR::DesignObject& 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;
        }
    };
};