DesignObjectBase.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: DesignObjectBase
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/TableColumnBuffer.h>
#include <NDEVR/Table.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/Set.h>
#include <NDEVR/RandomColorGenerator.h>
namespace NDEVR
{
    class JSONNode;
    template<uint01 t_dims, class t_type>
    class RTree;
    typedef AlocatingAlignedBuffer<JSONNode, 0> JSONBuffer;
    enum class PrimitiveProperty
    {
          Outline 
        , Solid 
        , Vertices 
        , Index_Property_Size 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<PrimitiveProperty>;
    enum class VertexProperty : uint01
    {
          Position = 0 
        , Normal = 1 
        , Tangent = 2 
        , BiTangent = 3 
        , Color = 4 
        , Texture = 5 
        , BitFlag = 6 
        , Bones = 7 
        , PreSmoothedPosition = 8 
        , Region = 9 
        , Vertex_Property_Size 
        , Invalid = 255 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<VertexProperty>;
    enum class VertexFlags : uint01
    {
          e_is_selected 
        , e_is_hidden 
        , e_is_locked 
        , e_is_filtered 
        , e_is_closure_location 
        , e_is_smooth 
    };

    enum class PrimitiveBitFlags
    {
          e_is_selected = 0x01 
        , e_is_hidden = 0x02 
        , e_is_locked = 0x04 
        , e_is_deleted = 0x08 
        , e_is_closure_primitive = 0x10 
    };

    enum class GeometryType
    {
          e_points 
        , e_linework 
        , e_triangles 
        , e_convex_polygons 
        , e_concave_polygons 
        , e_grids 
        , e_block_models 
        , e_geometry_type_size 
    };

    enum class WindingMode
    {
          e_no_winding 
        , e_clockwise_winding 
        , e_counterclockwise_winding 
        , e_indeterminate_winding 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<WindingMode>;
    enum class NormalMode
    {
          e_no_normals 
        , e_smooth_normals 
        , e_vertex_smooth_normals 
        , e_hard_normals 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<NormalMode>;
    enum class PrimitiveMode
    {
          e_no_index 
        , e_point 
        , e_lines 
        , e_polyline 
        , e_triangle 
        , e_triangle_fan 
        , e_triangle_strip 
        , e_grid 
        , e_block_model 
        , e_index_mode_size 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<PrimitiveMode>;
    enum class UVType
    {
          e_KD 
        , e_KS 
        , e_KA 
        , e_reflect 
        , e_emmisive 
        , e_normal 
        , e_displace 
        , e_uv_size 
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<UVType>;
    class WLock;
    class DesignObjectBase
    {
    public:
        NDEVR_DESIGN_API DesignObjectBase(bool is_app_owned);
        ~DesignObjectBase();
 
        // --- Tables ---
        Table property_table; 
        Table vertex_table; 
        Table primitive_index_table; 
        Table model_table; 
        Table material_table; 
        Table geometry_table; 
#if NDEVR_SUPPORTS_BONES
        Table bone_table; 
        uint04 bone_index = Constant<uint04>::Invalid; 
        uint04 bone_child_index = Constant<uint04>::Invalid; 
#endif
        Table effect_table; 
 
        // --- Design Object Columns ---
 
        Vector<38, TableColumn*> design_properties = Vector<38, TableColumn*>(nullptr); 
        ColumnT<uint04> model_index; 
        ColumnT<uint04> material_index; 
        ColumnT<uint04> geometry_index; 
        ColumnT<uint04> effect_index; 
 
        // --- High Efficiency Accessors ---
        ColumnT<UUID> guid; 
        ColumnT<Time> modified_time; 
        ColumnT<Time> asc_modified_time; 
        ColumnT<Time> desc_modified_time; 
        ColumnT<String> name; 
        ColumnT<uint01> design_type; 
        ColumnT<Matrix<fltp08>> transform; 
        TableVectorType<6, fltp08> bounding_box; 
        ColumnT<bool> spacial_visible; 
        ColumnT<bool> tree_visible; 
        ColumnT<bool> is_deleted; 
 
        // --- Material Columns ---
        Vector<28, TableColumn*> material_properties = Vector<28, TableColumn*>(nullptr); 
        Vector<10, TableColumn*> uv_image_file = Vector<10, TableColumn*>(nullptr); 
        Vector<10, TableColumn*> uv_intensity = Vector<10, TableColumn*>(nullptr); 
        Vector<10, TableColumn*> uv_color = Vector<10, TableColumn*>(nullptr); 
        Vector<10, TableColumn*> uv_layer = Vector<10, TableColumn*>(nullptr); 
        Vector<10, TableColumn*> uv_mode = Vector<10, TableColumn*>(nullptr); 
 
        // --- Geometry Table Columns ---
        Vector<21, TableColumn*> geometry_properties; 
        ColumnT<Buffer<uint04>> geometry_parent; 
        Vector<8, TableColumn*> primitive_property_mode_column; 
        Vector<8, ColumnT<uint04>*> primitive_property_offset_column; 
        Vector<8, ColumnT<uint04>*> primitive_property_size_column; 
        ColumnT<uint04> primitive_index_column; 
        ColumnT<uint04> primitive_fan_column; 
        ColumnT<uint01> primitive_flag_column; 
 
        ColumnT<uint04> index_mode_offset_column; 
        ColumnT<uint04> index_mode_size_column; 
 
        ColumnT<uint04> index_fan_offset_column; 
        ColumnT<uint04> index_fan_size_column; 
 
 
        Vector<16, TableColumn*> vertex_mode_column = Vector<16, TableColumn*>(nullptr); 
        ColumnT<uint04> vertex_offset_column; 
        ColumnT<uint04> vertex_count_column; 
        ColumnT<uint04> vertex_reserved_count_column; 
 
        ColumnT<uint04> solid_vertex_offset_column; 
        ColumnT<uint04> solid_vertex_count_column; 
        ColumnT<uint04> solid_vertex_reserved_count_column; 
 
 
        // --- Vertex Table Columns ---
        Vector<16, TableColumn*> vertex_property_column = Vector<16, TableColumn*>(nullptr); 
 
 
        // --- Model Columns ---
        Vector<18, TableColumn*> model_properties; 
        ColumnT<uint04> model_geometry_index; 
        ColumnT<Buffer<uint04>> effect_child_index; 
        ColumnT<Buffer<uint04>> local_child_location; 
        ColumnT<Buffer<uint04>> external_child_location; 
        ColumnT<uint04> parent_location; 
        ColumnT<uint04> layer_location; 
 
 
        ColumnT<String> model_type; 
        ColumnT<Bounds<3, fltp08>> visible_box; 
        ColumnT<Bounds<3, fltp08>> global_bounds; 
        ColumnT<Bounds<3, fltp08>> global_selection_bounds; 
        ColumnT<Matrix<fltp08>> complete_transform; 
        ColumnT<uint08> child_base_ptr; 
        ColumnT<uint08> parent_base_ptr; 
        ColumnT<uint04> inherited_flags; 
        ColumnT<uint04> personal_inherited_flags; 
        ColumnT<uint08> material_base_ptr; 
        ColumnT<uint08> geometry_base_ptr; 
        ColumnT<uint04> material_child_index; 
 
        // --- Effect Columns ---
        Vector<11, TableColumn*> effect_properties = Vector<11, TableColumn*>(nullptr); 
        ColumnT<Buffer<uint04>> effect_targets; 
        ColumnT<Buffer<uint08>> effect_extern_targets; 
 
 
        JSONBuffer cached_meta_data; 
        ColumnT<Buffer<uint04>>* neighbor_index_location = nullptr; 
        ColumnT<Buffer<uint04>>* face_to_edge_column = nullptr; 
        ColumnT<Buffer<uint04>>* edge_to_face_column = nullptr; 
    public:
        WLock lockRTrees();
        ConstPointer<RTree<3, fltp04>> getRTree(UUID id) const;
        DynamicPointer<RTree<3, fltp04>> getRTree(UUID id);
        const Dictionary<UUID, DynamicPointer<RTree<3, fltp04>>>& trees() const { return m_r_trees; }
        void setRTree(UUID id, const DynamicPointer<RTree<3, fltp04>>& tree);
        void removeRTree(UUID id);
        bool hasRTree(UUID id) const;
        void addTable(Table* table);
        void removeTable(const StringView& label);
        Table* table(const StringView& label);
        const Dictionary<UUID, Table*>& tables() { return m_tables; };
    public:
        Set<DesignObjectBase*>& referencedBases() { return m_referenced_bases; };
        Dictionary<String, DesignObjectBase*>& ownedBases() { return m_owned_bases; };
        bool isApplicationOwned() const;
        DesignObjectBase* base(const StringView& base);
        void addReference(DesignObjectBase* base);
        NDEVR_DESIGN_API void finishMapFromFile(BinaryFileTableInfo& info);
        NDEVR_DESIGN_API void fetchDataColumns(Buffer<TableColumn*>& columns);
        NDEVR_DESIGN_API void mapToFile(BinaryFileTableInfo& file) const;
        NDEVR_DESIGN_API void mapFromFile(BinaryFileTableInfo& file);
        NDEVR_DESIGN_API void mapTreeToFile(BinaryFileTableInfo& file, int mode) const;
        NDEVR_DESIGN_API void mapTreesFromFile(BinaryFileTableInfo& file);
        const RandomColorGenerator& randomColorGenerator() const { return m_color_generator; }
        NDEVR_DESIGN_API void readMetaDataFromColumn();
        NDEVR_DESIGN_API void writeMetaDataToColumn();
#ifdef _DEBUG
    public:
        const void* lock_ptr_check = nullptr; 
#endif
    protected:
        void createTables();
        void createPropertyTable();
        void createMaterialTable();
        void createGeometryTable();
        void createModelTable();
        void createEffectTable();
        void linkTables();
        void setDefaultValues();
        void setupStaticTables();
    private:
        Dictionary<UUID, Table*> m_tables; 
        Dictionary<String, Table*> m_custom_tables; 
 
        Dictionary<String, DesignObjectBase*> m_owned_bases; 
        Set<DesignObjectBase*> m_referenced_bases; 
        Dictionary<UUID, DynamicPointer<RTree<3, fltp04>>> m_r_trees; 
        RandomColorGenerator m_color_generator; 
        bool m_is_app_owned = false; 
    };
}