QtGraphicsWindow.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: NDEVR
File: QTGraphicsWindow
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/WindowInstance.h>
#include <NDEVR/QTModelManager.h>
#include <NDEVR/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 DynamicPointer<Camera>& camera) override;
        void exposeEvent(QExposeEvent* e) override;
        void setAnimating(bool animating);
        virtual bool visible() const override;
        virtual void setModelManager(QTModelManager* manager);
        void resizeEvent(QResizeEvent *resize_event) override;
        void finishFrame(GraphicsUpdateArguments& args) override;
        void updateSize();
        virtual bool shouldExit() const override;
        QImage getImage() const;
        virtual void makeCurrent() {}
        void pause(const TimeSpan& span);
        const DynamicPointer<GraphicsDevice>& device() const;
    public slots:
        void contextMenu(const QPoint &pos);
        void onClearAll();
        void setSize(const Vector<2, uint04>& size) final override;
        void onSelectionChanged(Buffer<UUID> selection, bool selected);
        void onFocusChanged(UUID focus, bool focussed);
        void updateFallbackStore();
        void setOverrideMaterial(UUID material);
        void renderSlot();
    signals:
        void onSelectedSignal(Buffer<UUID> selected);
        void requestContextMenu(const QPoint &pos);
        void hideContextMenuSignal();
        void renderShowing();
        void mouseInScreenSignal(bool mouse_in_screen);
    protected:
        void graphicsUpdate();
        bool event(QEvent *event) override;
        Renderer* getRenderer();
        void createMouseListener();
        //void exposeEvent(QExposeEvent *event) override;
    protected:
        Renderer* m_render; 
#if NDEVR_SUPPORTS_THREADING
        //Thread* m_render_thread;
#endif
        QTimer* m_touch_context_timer = nullptr; 
        QPointF m_touch_begin_point; 
        QTimer* m_fps_timer = nullptr; 
        QTModelManager* m_manager; 
        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_initiation_failure; 
        bool m_instance_valid = false; 
        bool m_touch_alternate = 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(const DynamicPointer<Camera>& camera);
        void setModelManager(QTModelManager* manager);
        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>::Invalid; 
#if !NDEVR_SPECIAL_GRAPHICS_WINDOW
        GlobalGraphicsWidgetEventFilter* m_filter;
#endif
    };
    
}