DesignObjectLookup.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: DesignObjectLookup
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObject.h>
#include <NDEVR/Model.h>
#include <NDEVR/Scene.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;
    class NDEVR_DESIGN_API DesignObjectLookup
    {
    public:
        DesignObjectLookup();
        virtual ~DesignObjectLookup();
        [[nodiscard]] WLock writeLock() const;
        [[nodiscard]] RLock readLock() const;
        void setupDefaultScene();

        [[nodiscard]] WLock writeLock(const std::function<void()>& wait_callback);
        [[nodiscard]] RLock readLock(const std::function<void()>& wait_callback) const;

        [[nodiscard]] WLock tryWriteLock(uint08 milliseconds = 10);
        [[nodiscard]] RLock tryReadLock(uint08 milliseconds = 10) const;

        [[nodiscard]] WLock tryWriteLock(const TimeSpan& span);
        [[nodiscard]] RLock tryReadLock(const TimeSpan& span) const;

        [[nodiscard]] WLock commandLock();
        [[nodiscard]] WLock tryCommandLock();
        bool isCommandLocked() const;
        const void* lockPtr() const;
        [[nodiscard]] RDesignLock readLock(UUID id);
        [[nodiscard]] WDesignLock writeLock(UUID id);

        virtual void addScene(Scene scene, bool add_all_scene_models = true);
        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);
        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 Material restoreMaterial(UUID id);
        virtual void setActiveLayer(UUID layer_id);
        virtual void setActiveProject(UUID layer_id);
        [[nodiscard]] virtual UUID activeProject() const { return m_active_project; }
        [[nodiscard]] virtual Project activeProjectModel() const;
        void ensureLayerExistsInScene(const UUID& layer_id, const UUID& scene_id);
        void deleteLayer(const UUID& layer_id, const UUID& scene_id);
        void ensureLayerExistsInAllScenes(const UUID& layer_id);
        void addUpdateTarget(DesignObjectUpdateTarget* target);
        void removeUpdateTarget(DesignObjectUpdateTarget* target);
        [[nodiscard]] virtual uint08 approximateMemorySize(bool include_app_owned = false) const;
        [[nodiscard]] Geometry geometry(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Material material(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Scene scene(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Model modelOrLayer(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Model model(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Buffer<Model> models(const Buffer<UUID>& ids, bool allow_deleted = false) const;
        [[nodiscard]] Effect effect(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Model layer(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] Model layer(const UUID& layer_id, const UUID& scene_id, bool allow_deleted = false) const;
        [[nodiscard]] Model findLayer(const String& layer, bool use_translation = true) const;
        [[nodiscard]] Model findLayer(const TranslatedString& layer) const;
#if NDEVR_VIEWPORT
        [[nodiscard]] DynamicPointer<Camera> createCamera(Model& parent, const ViewportFormat& format);
        [[nodiscard]] DynamicPointer<Camera> createCamera(const ViewportFormat& format);
        [[nodiscard]] bool hasCamera(const UUID& id) const;
        virtual void addCamera(const DynamicPointer<Camera>& object, bool generate_decorations = true);
        [[nodiscard]] DynamicPointer<Camera> getCamera(const UUID& id);
        [[nodiscard]] ConstPointer<Camera> getCamera(const UUID& id) const;
        [[nodiscard]] Bounds<3, fltp08> boundsOfVisible(const Camera& camera) const;
        [[nodiscard]] virtual CameraManager* cameraManager();
        [[nodiscard]] virtual const CameraManager* cameraManager() const;
        [[nodiscard]] virtual SelectionController* selectionController();
        [[nodiscard]] virtual ModelEditController* editManager();
        [[nodiscard]] virtual SelectionEffect* selectionEffect();
        void setViewportFocus(AutoZoomFocus focus);
#endif
        [[nodiscard]] virtual DesignCommandManager* commandManager();
        [[nodiscard]] const DynamicPointer<DesignSelection>& getSelectionInfo(const UUID& id);
        [[nodiscard]] const ConstPointer<DesignSelection>& getSelectionInfo(const UUID& id) const;

        [[nodiscard]] bool hasModelID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasSceneID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasObjectID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasMaterialID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasGeometryID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasEffect(const UUID& id) const;
        [[nodiscard]] bool hasSelectionInfo(const UUID& id) const;
        [[nodiscard]] bool hasLayerID(const UUID& id, bool allow_deleted = false) const;
        [[nodiscard]] bool hasLayerID(const UUID& id, const UUID& scene_id) const;
        [[nodiscard]] const Dictionary<UUID, Model>& getAllSceneLayers(const UUID& id) const;

        [[nodiscard]] DesignObject object(const UUID& id) const;
        [[nodiscard]] Buffer<UUID> getRootObjectIDs(bool include_app_owned = false) const;
        [[nodiscard]] Buffer<UUID> getRootObjectIDs(UUID camera_id, bool include_app_owned = false) const;
        [[nodiscard]] Set<UUID> getExcludedIDs(UUID camera_id) const;
        [[nodiscard]] Buffer<Model> getRootObjects(bool include_app_owned = false) const;
        [[nodiscard]] Buffer<Model> getRootObjects(UUID camera_id, bool include_app_owned = false) const;
        [[nodiscard]] Buffer<Model> getCameraObjects() const;
        void processSelection(SelectionInfo& info) const;
        Dictionary<UUID, EnclosedModelInfo> processSelection(const DesignSelection& info) const;
        void colorByChannel(UUID target, const DesignParameter& channel);
        [[nodiscard]] Bounds<3, fltp08> bounds() const;
        [[nodiscard]] Bounds<3, fltp08> boundsOfVisible() const;
        [[nodiscard]] Buffer<UUID> selected() const;
        [[nodiscard]] virtual LogManager* logManager() const;
        [[nodiscard]] virtual DesignTaskManager* taskManager() const;
        template<class t_design_command_type>
        void postCommand(const DynamicPointer<t_design_command_type>& command)
        {
            postDesignCommand(command.template as<DesignCommand>());
        }

        virtual void postDesignCommand(const DynamicPointer<DesignCommand>& command);
        template<class t_design_command_type>
        void runCommand(const DynamicPointer<t_design_command_type>& command)
        {
            runDesignCommand(command.template as<DesignCommand>());
        }

        virtual void runDesignCommand(const DynamicPointer<DesignCommand>& command);
        virtual void finishCommand(const DynamicPointer<DesignCommand>& command);
        //virtual void addCameraObject(UUID camera, const Model& object);
        [[nodiscard]] Buffer<UUID> getModelIDsByType(const StringView& type) const;
        [[nodiscard]] Buffer<Model> getModelsByType(const StringView& type) const;
        [[nodiscard]] Buffer<Model> getModelsByType(const Buffer<String>& types) const;
        [[nodiscard]] bool hasModelsOfType(const StringView& type) const;
        [[nodiscard]] Buffer<Model> getLayersByType(const StringView& type) const;
        [[nodiscard]] bool hasLayersOfType(const StringView& type) const;
        [[nodiscard]] Buffer<Model> getLayersByType(const Buffer<String>& types) const;
        [[nodiscard]] Buffer<Model> getModelsByID(const Buffer<UUID>& ids) const;
        [[nodiscard]] Buffer<Model> getModelsByID(const Set<UUID>& ids) const;
        [[nodiscard]] Buffer<Model> getModelsByName(const StringView& name) const;
        void setSelectionEffect(SelectionEffect* effect);

        [[nodiscard]] const Scene& defaultScene() { return m_default_scene; }
        [[nodiscard]] Material createMaterial();
        [[nodiscard]] Material createCameraMaterial(UUID camera);
        [[nodiscard]] const Dictionary<UUID, Scene>& sceneObjects() { return m_scene_objects; };
        [[nodiscard]] const Dictionary<UUID, Model>& modelObjects() { return m_model_objects; };
        [[nodiscard]] const Dictionary<UUID, Dictionary<UUID, Model>>& layerObjects() { return m_layer_objects; };
        [[nodiscard]] const Dictionary<UUID, Material>& materialObjects() { return m_material_objects; };
        [[nodiscard]] const Dictionary<UUID, Geometry>& geometryObjects() { return m_geometry_objects; };
        [[nodiscard]] const Dictionary<UUID, DesignObject>& objects() { return m_design_objects; };
        [[nodiscard]] const Dictionary<UUID, Effect>& effectObjects() { return m_effect_objects; };
        [[nodiscard]] const Dictionary<UUID, DesignObject>& deletedObjects() { return m_deleted_objects; };
        void removeDeletedObject(UUID id) { m_deleted_objects.erase(id); };
        [[nodiscard]] Buffer<UUID> visibleModels() const;
        [[nodiscard]] Geometry createMesh();
        [[nodiscard]] Model createModel();
        [[nodiscard]] Model createCameraModel(UUID camera);
        [[nodiscard]] 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 performDeletion(Buffer<UUID> deleted_objects);
        void cleanupMemory();
        virtual void update(const Time& time, const std::function<void()>& wait_callback);
        virtual void requestAutoSave();
        virtual void requestAutoSaveCheckpoint();
        [[nodiscard]] virtual Buffer<UUID> getInverseOf(const Buffer<UUID>& model_ids);
        [[nodiscard]] virtual Buffer<UUID> getDescendantsOf(const Buffer<UUID>& model_ids);
        void selectEnclosed(UUID selection_id);
        [[nodiscard]] Buffer<DesignParameter> designParameters() const;
        [[nodiscard]] Buffer<DesignParameterAccumulator> accumulateDesignParameters(const BitFlag& accumulation_flags) const;
        [[nodiscard]] 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;
        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_referenced_scenes;
        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, std::pair<UUID, uint04>> m_erased_objects;
        Dictionary<UUID, Model> m_model_root_objects;
        Dictionary<UUID, Model> m_referenced_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;
        Buffer<UUID> m_selected_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_preferred_update_timespan;
        bool m_update_station_visuals;
        bool m_update_station_font;
        bool m_update_language;
        UUID m_uuid;
    };
 
}