CameraManager.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: 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
*-----------------------------------------------------------------------------------------------**/
 
namespace std
{
 
    /**--------------------------------------------------------------------------------------------------
    Struct: hash<NDEVR::UUID>
 
    Used to make this item work with standard hash tables.
 
    Author: Tyler Parke
 
    Date: 2017-11-17
    *-----------------------------------------------------------------------------------------------**/
    template<>
    struct hash<std::pair<NDEVR::UUID, NDEVR::UUID>>
    {
        /**--------------------------------------------------------------------------------------------------
        Fn: size_t operator()(const UUID& value) const
 
        Function call operator. Used to make this item work with standard hash tables.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        value -  The value.
 
        Returns: The result of the operation.
        *-----------------------------------------------------------------------------------------------**/
 
        size_t operator()(const std::pair<NDEVR::UUID, NDEVR::UUID>& value) const
        {
            hash<NDEVR::UUID> hasher;
            return hasher(value.first) ^ hasher(value.second);
        }
    };
 
    /**--------------------------------------------------------------------------------------------------
    Struct: equal_to<NDEVR::UUID>
 
    An uuid>.
 
    Author: Tyler Parke
 
    Date: 2017-11-17
    *-----------------------------------------------------------------------------------------------**/
    template <>
    struct equal_to<std::pair<NDEVR::UUID, NDEVR::UUID>>
    {
        /**--------------------------------------------------------------------------------------------------
        Fn: bool operator()(const NDEVR::UUID& x, const NDEVR::UUID& y) const
 
        Function call operator.
 
        Author: Tyler Parke
 
        Date: 2017-11-17
 
        Parameters:
        x -         A NDEVR::UUID to process.
        y -         A NDEVR::UUID to process.
 
        Returns: The result of the operation.
        *-----------------------------------------------------------------------------------------------**/
 
        bool operator()(const std::pair<NDEVR::UUID, NDEVR::UUID>& x, const std::pair<NDEVR::UUID, NDEVR::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(DesignObjectBase& base);
        ~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, const 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);
        void updateCamera(const ViewportFormat& format);
        bool hasCamera(UUID id) const;
        const DynamicPointer<Camera>& getCamera(UUID id) const
        {
            return m_cameras.get(id);
        }
        const DynamicPointer<Camera>& getCamera(UUID id)
        {
            return m_cameras.get(id);
        }
        uint04 cameraCount() const
        {
            return m_cameras.size();
        }
        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);
        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);
        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);//used if no default
        void updateCameraBackgrounds();
        void setCameraShowGrid(bool show_grid);
        void setCameraShowEnvironment(bool show_grid);
        void addMouseCursor(UUID id, const String& 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;
    protected:
        Buffer<ViewportLayout> m_viewport_layout_stack;
        DynamicPointer<SnapsManager> m_snap_manager;
        Dictionary<UUID, Skybox*> m_skyboxes;
        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;
        DesignObjectBase& m_base;
        RGBColor m_theme_camera_background_color;//used if no default camera 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