DesignObjectLookup.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: DesignObjectLookup
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObject.h>
#include <NDEVR/Model.h>
#include <NDEVR/Effect.h>
#include <NDEVR/DesignSelection.h>
#include <NDEVR/CameraManager.h>
#include <NDEVR/LogManager.h>
#include <NDEVR/DesignParameterAccumulator.h>
 
namespace NDEVR
{
    class RDesignLock;
    class WDesignLock;
 
    class Log;
    class WLock;
    class RLock;
    class SelectionController;
    class ModelEditController;
    class SelectionInfo;
    class SelectionEffect;
    class DesignCommandManager;
    class ResourceListener;
    class DesignTaskManager;
    class Project;
    class DesignObjectUpdateTarget;
    class Thread;
    /**--------------------------------------------------------------------------------------------------
    \brief A core class where all Design Objects including models, materials, and geometries are stored.
        Contains the logic necessary to build or display any number of Scenes simultaniously
    **/
    class NDEVR_DESIGN_API DesignObjectLookup
    {
    public:
        DesignObjectLookup();
        virtual ~DesignObjectLookup();
        WLock writeLock();
        RLock readLock() const;
        void setupDefaultScene();
 
        WLock writeLock(const std::function<void()>& wait_callback);
        RLock readLock(const std::function<void()>& wait_callback) const;
        
        WLock tryWriteLock(uint08 milliseconds = 10);
        RLock tryReadLock(uint08 milliseconds = 10) const;
 
        WLock tryWriteLock(const TimeSpan& span);
        RLock tryReadLock(const TimeSpan& span) const;
 
        WLock commandLock();
        WLock tryCommandLock();
        bool isCommandLocked() const;
        const void* lockPtr() const;
        RDesignLock readLock(UUID id);
        WDesignLock writeLock(UUID id);
 
        virtual void addScene(Scene scene, bool ignore_application_scene = false);
        virtual void addMaterial(Material object);
        virtual void addGeometry(Geometry object);
        virtual void addEffect(Effect object);
        virtual void addModel(Model object);
        virtual void addCameraModel(const UUID& camera, const Model& object);
        virtual void addLayer(Model layer);
        virtual void addSelection(const DesignSelection& object);
        virtual void clearSelected();
        virtual void setSelected(Buffer<UUID> ids);
        virtual void appendSelected(Buffer<UUID> ids);
        virtual void refreshScene(UUID scene_id, bool ignore_application_scene);
        virtual void refreshModel(const Model& object);
 
        virtual void updateModelTopLevel(const Model& object);
        virtual void executePendingCommands();
        virtual void deleteObject(UUID id);
        virtual void eraseModel(UUID id);
        virtual Model restoreModel(UUID id);
        virtual void setActiveLayer(UUID layer_id);
        virtual void setActiveProject(UUID layer_id);
        virtual UUID activeProject() const { return m_active_project; }
        virtual Project activeProjectModel() const;
        void ensureLayerExistsInScene(const UUID& layer_id, const UUID& scene_id);
        void addUpdateTarget(DesignObjectUpdateTarget* target);
        void removeUpdateTarget(DesignObjectUpdateTarget* target);
        Geometry geometry(const UUID& id, bool allow_deleted = false) const;
        Material material(const UUID& id, bool allow_deleted = false) const;
        Scene scene(const UUID& id, bool allow_deleted = false) const;
        Model modelOrLayer(const UUID& id, bool allow_deleted = false) const;
        Model model(const UUID& id, bool allow_deleted = false) const;
        Effect effect(const UUID& id, bool allow_deleted = false) const;
        Model layer(const UUID& id, bool allow_deleted = false) const;
        Model layer(const UUID& layer_id, const UUID& scene_id, bool allow_deleted = false) const;
        Model findLayer(const String& layer, bool use_translation = true) const;
        Model findLayer(const TranslatedString& layer) const;
#if NDEVR_VIEWPORT
        DynamicPointer<Camera> createCamera(Model& parent, const ViewportFormat& format);
        DynamicPointer<Camera> createCamera(const ViewportFormat& format);
        bool hasCamera(const UUID& id) const;
        virtual void addCamera(const DynamicPointer<Camera>& object);
        const DynamicPointer<Camera>& getCamera(const UUID& id);
        const ConstPointer<Camera>& getCamera(const UUID& id) const;
        Bounds<3, fltp08> boundsOfVisible(const Camera& camera) const;
        virtual CameraManager* cameraManager();
        virtual const CameraManager* cameraManager() const;
        virtual SelectionController* selectionController();
        virtual ModelEditController* editManager();
        virtual SelectionEffect* selectionEffect();
        void setViewportFocus(AutoZoomFocus focus);
#endif
        virtual DesignCommandManager* commandManager();
        const DynamicPointer<DesignSelection>& getSelectionInfo(const UUID& id);
        const ConstPointer<DesignSelection>& getSelectionInfo(const UUID& id) const;
 
        bool hasModelID(const UUID& id, bool allow_deleted = false) const;
        bool hasSceneID(const UUID& id, bool allow_deleted = false) const;
        bool hasObjectID(const UUID& id, bool allow_deleted = false) const;
        bool hasMaterialID(const UUID& id) const;
        bool hasGeometryID(const UUID& id) const;
        bool hasEffect(const UUID& id) const;
        bool hasSelectionInfo(const UUID& id) const;
        bool hasLayerID(const UUID& id, bool allow_deleted = false) const;
        bool hasLayerID(const UUID& id, const UUID& scene_id) const;
        const Dictionary<UUID, Model>& getAllSceneLayers(const UUID& id) const;
 
        DesignObject object(const UUID& id) const;
        Buffer<UUID> getRootObjectIDs(bool include_app_owned = false) const;
        Buffer<UUID> getRootObjectIDs(UUID camera_id, bool include_app_owned = false) const;
        Buffer<Model> getRootObjects(bool include_app_owned = false) const;
        Buffer<Model> getRootObjects(UUID camera_id, bool include_app_owned = false) const;
        void processSelection(SelectionInfo& info) const;
        void colorByChannel(UUID target, const DesignParameter& channel);
        Bounds<3, fltp08> bounds() const;
        Bounds<3, fltp08> boundsOfVisible() const;
        
        
        virtual LogManager* logManager() const;
        virtual DesignTaskManager* taskManager() const;
        virtual void postCommand(const DynamicPointer<DesignCommand>& command);
        virtual void runCommand(const DynamicPointer<DesignCommand>& command);
        virtual void finishCommand(const DynamicPointer<DesignCommand>& command);
        //virtual void addCameraObject(UUID camera, const Model& object);
        Buffer<UUID> getModelIDsByType(const String& type) const;
        Buffer<Model> getModelsByType(const String& type) const;
        Buffer<Model> getModelsByType(const Buffer<String>& types) const;
        Buffer<Model> getLayersByType(const String& type) const;
        Buffer<Model> getLayersByType(const Buffer<String>& types) const;
        Buffer<Model> getModelsByID(const Buffer<UUID>& ids) const;
        Buffer<Model> getModelsByName(const String& name) const;
        void setSelectionEffect(SelectionEffect* effect);
 
        const Scene& defaultScene() { return m_default_scene; }
        Material createMaterial();
        Material createCameraMaterial(UUID camera);
        const Dictionary<UUID, Scene>& sceneObjects() { return m_scene_objects; };
        const Dictionary<UUID, Model>& modelObjects() { return m_model_objects; };
        const Dictionary<UUID, Dictionary<UUID, Model>>& layerObjects() { return m_layer_objects; };
        const Dictionary<UUID, Material>& materialObjects() { return m_material_objects; };
        const Dictionary<UUID, Geometry>& geometryObjects() { return m_geometry_objects; };
        const Dictionary<UUID, DesignObject>& objects() { return m_design_objects; };
        const Dictionary<UUID, Effect>& effectObjects() { return m_effect_objects; };
        const Dictionary<UUID, DesignObject>& deletedObjects() { return m_deleted_objects; };
        void removeDeletedObject(UUID id) { m_deleted_objects.erase(id); };
        Buffer<UUID> visibleModels() const;
        Geometry createMesh();
        Model createModel();
        Model createCameraModel(UUID camera);
        Model createLayer();
        void invalidateStationVisuals(bool invalidate_visuals, bool invalidate_font);
        void updateTranslation();
        
        virtual void clearAll();
#if NDEVR_SUPPORTS_THREADING
        void startUpdateThread(const TimeSpan& span, std::function<void(const Exception&)> exception_callback);
        void stopUpdateThread();
#endif
        void cleanupMemory(Buffer<UUID> deleted_objects);
        virtual void update(const Time& time, const std::function<void()>& wait_callback);
        virtual void requestAutoSave();
        virtual void requestAutoSaveCheckpoint();
        virtual Buffer<UUID> getInverseOf(const Buffer<UUID>& model_ids);
        virtual Buffer<UUID> getDescendentsOf(const Buffer<UUID>& model_ids);
        void selectEnclosed(UUID selection_id);
        Buffer<DesignParameter, uint04, ObjectAllocator<false>> designParameters() const;
        Buffer<DesignParameterAccumulator, uint04, ObjectAllocator<false>> accumulateDesignParameters(const BitFlag& accumulation_flags) const;
        DesignParameterAccumulator accumulateDesignParameter(const DesignParameter& channel, const BitFlag& accumulation_flags) const;
    public:
        Resource<RGBColor> focus_color;
        Resource<UUID> current_layer;
        Resource<Time> modified_time;
        Resource<Time> autosave_request_time;
        Resource<Time> autosave_checkpoint_request_time;
    protected:
#if NDEVR_SUPPORTS_THREADING
        Thread* m_update_thread = nullptr;
        std::function<void(const Exception&)> m_exception_callback = nullptr;
#endif
        void updateEffects(const Time& time, const std::function<void()>& wait_callback);
        //virtual void refreshObject(UUID object);
        UUID m_active_layer;
        UUID m_active_project;
        Scene m_default_scene;//This is constant to the application (Does not get written to files)
        SelectionController* m_selection_controller;
        ModelEditController* m_edit_controller;
        DesignCommandManager* m_command_controller;
#if NDEVR_VIEWPORT
        CameraManager* m_camera_controller;
#endif
        SelectionEffect* m_selection_effect;
        mutable LogManager* m_log_manager;
        mutable DesignTaskManager* m_task_controller;
        Dictionary<UUID, Model> m_camera_root;
        Dictionary<UUID, Scene> m_all_scene_objects;
        Dictionary<UUID, Scene> m_scene_objects;
        Dictionary<UUID, Model> m_model_objects;
        Dictionary<UUID, DesignObject> m_design_objects;
        Dictionary<UUID, DesignObject> m_deleted_objects;
        Dictionary<UUID, UUID> m_erased_objects;
        Dictionary<UUID, Model> m_model_root_objects;
        Dictionary<UUID, Model> m_application_root_objects;
        Dictionary<UUID, Dictionary<UUID, Model>> m_layer_objects;
        Dictionary<UUID, Material> m_material_objects;
        Dictionary<UUID, Geometry> m_geometry_objects;
        Dictionary<UUID, Effect> m_effect_objects;
        Dictionary<UUID, DynamicPointer<DesignSelection>> m_selection_info;
        ResourceListener* m_invalidate_station_visuals_listener;
        ResourceListener* m_language_change_listener;
        Buffer<DesignObjectUpdateTarget*> m_update_targets;
        Time m_last_update_time;
        TimeSpan m_prefered_update_timespan;
        bool m_update_station_visuals;
        bool m_update_station_font;
        bool m_update_language;
        UUID m_uuid;
    };
 
}