CameraManager.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: CameraManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/Camera.h>
#include <NDEVR/MouseController.h>
#include <NDEVR/ViewportLayout.h>
#include <NDEVR/KeyController.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Pointer.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Dictionary.h>
#if NDEVR_VIEWPORT
namespace std
{

    template<>
    struct hash<std::pair<UUID, UUID>>
    {
 
        size_t operator()(const std::pair<UUID, UUID>& value) const
        {
            hash<UUID> hasher;
            return hasher(value.first) ^ hasher(value.second);
        }
    };

    template <>
    struct equal_to<std::pair<UUID, UUID>>
    {
 
        bool operator()(const std::pair<UUID, UUID>& x, const std::pair<UUID, UUID>& y) const
        {
            return x == y;
        }
    };
};
namespace NDEVR
{
    class KeyControllerBase; 
    class MouseControllerBase; 
    class MouseController; 
    class KeyController; 
    class SnapsManager; 
    class Skybox; 
    class NDEVR_DESIGN_API CameraManager
    {
    private:
        class CameraOrientationSync; 
        class CameraOffsetSync; 
    public:
        CameraManager();
        ~CameraManager();
        void addCamera(DynamicPointer<Camera> camera);
        const ConstPointer<SnapsManager>& snapsManager() const
        {
            return m_snap_manager;
        }

        const DynamicPointer<SnapsManager>& snapsManager()
        {
            return m_snap_manager;
        }

        void update(const Time& time, DesignObjectLookup* lookup);
        const DynamicPointer<MouseController>& mouseController(UUID id)
        {
            return m_mouse_controllers.get(id);
        }

        const DynamicPointer<KeyController>& keyController(UUID id)
        {
            return m_key_controllers.get(id);
        }

        DynamicPointer<Camera> createCamera(Model& parent, ViewportFormat format, DesignObjectLookup* lookup);
        void updateCamera(const ViewportFormat& format);
        bool hasCamera(UUID id) const;
        DynamicPointer<Camera> getCamera(UUID id) const
        {
            const auto& camera = m_cameras.find(id);
            if (camera != m_cameras.end())
                return camera.value();
            return DynamicPointer<Camera>();
        }

        uint04 cameraCount() const
        {
            return m_cameras.size();
        }

        void saveLayout();
        void clearAll();
        uint04 userCameraCount() const;
        DynamicPointer<Camera> selectedCamera() const;
        Buffer<DynamicPointer<Camera>> userCameras() const;
        Buffer<UUID> userCameraIDs() const;
        Buffer<UUID> cameraIDs() const;
        void setSkybox(UUID camera, Skybox* skybox);
        void addCameraModel(const UUID& camera, const Model& object);
        Skybox* getSkybox(UUID camera_id) const;
        const DynamicPointer<Camera>& getCameraFromIndex(uint04 id)
        {
            return m_index_cameras[id];
        }

        const ConstPointer<Camera>& getCameraFromIndex(uint04 id) const
        {
            return m_index_cameras[id];
        }

        void deleteCamera(UUID id, bool delete_model = true);
        void linkCameraOrientation(UUID a, UUID b);
        void selectCamera(UUID camera);
        void delinkCameraOrientation(UUID a, UUID b);
        void addKeyController(UUID camera, UUID id, KeyControllerBase* actions);
        void removeKeyController(UUID camera, UUID id);
        void addKeyController(UUID id, KeyControllerBase* actions);
        void removeKeyController(UUID id);
        void addMouseController(UUID camera, UUID id, MouseControllerBase* actions);
        void removeMouseController(UUID camera, UUID id);
        void addMouseController(UUID id, MouseControllerBase* actions);
        void removeMouseController(UUID id);
        void setThemeCameraBackgroundColor(const RGBColor& color);
        void updateCameraBackgrounds();
        void setCameraShowGrid(bool show_grid);
        void setCameraShowEnvironment(bool show_grid);
        void addMouseCursor(UUID id, const StringView& cursor);
        void removeMouseCursor(UUID id);
        void addViewportLayout(const ViewportLayout& layout);
        void updateViewportLayout(const ViewportLayout& layout);
        void setDefaultLayoutTheme(ViewportLayoutTheme theme);
        void removeViewportLayout(const UUID& id);
        RGBColor defaultCameraBackgroundColor() const;
        Resource<ViewportLayout> current_layout; 
        Resource<bool> camera_show_grid; 
        Resource<bool> camera_show_environment; 
    private:
        Buffer<ViewportLayout> m_viewport_layout_stack; 
        DynamicPointer<SnapsManager> m_snap_manager; 
        Dictionary<UUID, Skybox*> m_skyboxes; 
        Set<std::pair<UUID, UUID>> m_default_hidden_items; 
        Dictionary<std::pair<UUID, UUID>, CameraOrientationSync*> m_camera_orientation_syncs; 
        Dictionary<std::pair<UUID, UUID>, CameraOffsetSync*> m_camera_offset_syncs; 
        Buffer<DynamicPointer<Camera>> m_index_cameras; 
        Dictionary<UUID, DynamicPointer<Camera>> m_cameras; 
        Dictionary<UUID, DynamicPointer<MouseController>> m_mouse_controllers; 
        Dictionary<UUID, DynamicPointer<KeyController>> m_key_controllers; 
        Buffer<UUID> m_global_mouse_actions; 
        Dictionary<UUID, MouseControllerBase*> m_global_mouse_action_lookup; 
        Buffer<UUID> m_global_key_actions; 
        Dictionary<UUID, KeyControllerBase*> m_global_key_action_lookup; 
        RGBColor m_theme_camera_background_color; 
        Buffer<std::pair<UUID, String>> m_global_mouse_cursors; 
        Dictionary<UUID, String> m_global_mouse_cursor_lookup; 
        UUID m_active_camera; 
        BasicResourceListener* m_color_theme_listener; 
    };
}
#endif