QtGraphicsWindow.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: NDEVR
File: QTGraphicsWindow
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include "Design/Headers/WindowInstance.h"
#include "NDEVR/Headers/QTModelManager.h"
#include "Widgets/Headers/WindowContainer.h"
#include <QWidget>
#include <QWindow>
class QVulkanInstance;
struct VkSurfaceKHR_T;
#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
#include <QVulkanWindow>
    typedef QVulkanWindow GraphicsWindowBase;
#else
    typedef QWindow GraphicsWindowBase;
#endif
namespace NDEVR
{
    class Renderer;
    class BasicThread;
    class BasicResourceListener;
    class QTResourceListener;
    class NDEVR_GRAPHICS_API QTGraphicsWindow : public QWindow, public WindowInstance
    {
        Q_OBJECT
        friend class QTGraphicsWidget;
        friend class RenderThread;
    public:
        //explicit QTGraphicsWindow(QWindow* parent, UUID camera, Log* log, QTModelManager* manager, Qt::WindowFlags flags);
        explicit QTGraphicsWindow(const DynamicPointer<GraphicsDevice>& device, QWindow* parent, Qt::WindowFlags flags);
        ~QTGraphicsWindow();
 
        virtual void initialize();
        void setCamera(const UUID& camera) override;
        void exposeEvent(QExposeEvent* e) override;
        void setAnimating(bool animating);
        virtual bool visible() const override;
        virtual void setModelManager(QTModelManager* manager, bool auto_add_models);
        void resizeEvent(QResizeEvent *resize_event) override;
        void finishFrame(GraphicsUpdateArguments& args) override;
        void updateSize();
        virtual bool shouldExit() const override;
        QImage getImage() const;
        void setExposed(bool exposed);
        void flushBackingStore();
        void pause(const TimeSpan& span);
        const DynamicPointer<GraphicsDevice>& device() const;
    public slots:
        void contextMenu(const QPoint &pos);
 
        void setSize(const Vector<2, uint04>& size) final override;
        void addCameraObjectSlot(UUID camera_id, UUID model);
        void addScene(Buffer<UUID> model);
        void addModel(Buffer<UUID> model);
        void clearModels();
        void onSelectionChanged(Buffer<UUID> selection, bool selected);
        void onFocusChanged(UUID focus, bool focussed);
        void removeModel(UUID model);
        void updateFallbackStore();
        void setOverrideMaterial(UUID material);
    signals:
        void onSelectedSignal(Buffer<UUID> selected);
        void requestContextMenu(const QPoint &pos);
        void renderShowing();
        void mouseInScreenSignal(bool mouse_in_screen);
    protected:
        bool event(QEvent *event) override;
        Renderer* getRenderer();
        void createMouseListener();
        void addRootModels();
        //void exposeEvent(QExposeEvent *event) override;
    protected:
        Renderer* m_render;
#if NDEVR_SUPPORTS_THREADING
        Thread* m_render_thread;
#endif
        QTModelManager* m_manager;
        Buffer<UUID> m_models_to_add;
        QTResourceListener* m_mouse_manager_listener;
        QBackingStore* m_backing_store = nullptr;
        bool m_is_init;
        bool m_is_size_valid;
        bool m_animating;
        bool m_has_valid_khr;
        bool m_is_exposed;
        bool m_initiation_failure;
        bool m_auto_add_models;
        bool m_instance_valid = false;
        QRect m_last_render_size;
        DynamicPointer<GraphicsDevice> m_device;
        Q_DISABLE_COPY(QTGraphicsWindow)
    };
    class GlobalGraphicsWidgetEventFilter;
    class NDEVR_GRAPHICS_API QTGraphicsWidget : public WindowContainer
    {
        Q_OBJECT
    public:
        QTGraphicsWidget(QTGraphicsWindow* window, QWidget* parent = nullptr);
        virtual ~QTGraphicsWidget();
        bool eventCallback(QEvent* event);
        bool eventFilter(QObject* watched, QEvent* e) override;
        void updateSize() override;
        void setCamera(UUID camera);
        void setModelManager(QTModelManager* manager, bool auto_add_models);
        void updateBackgroundColor();
        QTGraphicsWindow* graphicsWindow() { return m_window; }
    signals:
        void mouseInScreenSignal(bool mouse_in_screen);
    protected:
        QTGraphicsWindow* m_window;
        QTimer* m_check_visibility_timer;
        RGBColor m_background_color = Constant<RGBColor>::NaN;
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
        GlobalGraphicsWidgetEventFilter* m_filter;
#endif
    };
    
}