MinimalScene.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2017 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_GUI_PLUGINS_MINIMALSCENE_HH_
#define GZ_GUI_PLUGINS_MINIMALSCENE_HH_
 
#include <string>
#include <memory>
#include <optional>
 
#include <gz/common/KeyEvent.hh>
#include <gz/common/MouseEvent.hh>
#include <gz/math/Color.hh>
#include <gz/math/Pose3.hh>
#include <gz/math/Vector2.hh>
#include <gz/utils/ImplPtr.hh>
#include <gz/rendering/GraphicsAPI.hh>
#include <gz/rendering/Light.hh>
 
#include "gz/gui/Plugin.hh"
 
#include "MinimalSceneRhi.hh"
 
namespace gz::gui::plugins
{
  class MinimalScene : public Plugin
  {
    Q_OBJECT
 
    Q_PROPERTY(
      QString loadingError
      READ LoadingError
      WRITE SetLoadingError
      NOTIFY LoadingErrorChanged
    )
 
    
    public: MinimalScene();
 
    public slots: void OnHovered(int _mouseX, int _mouseY);
 
    public slots: void OnFocusWindow();
 
    public slots: void OnDropped(const QString &_drop,
        int _mouseX, int _mouseY);
 
    // Documentation inherited
    public: virtual void LoadConfig(const tinyxml2::XMLElement *_pluginElem)
        override;
 
    public: Q_INVOKABLE QString LoadingError() const;
 
    public: Q_INVOKABLE void SetLoadingError(const QString &_loadingError);
 
    signals: void LoadingErrorChanged();
 
    public: QString loadingError;
 
    GZ_UTILS_UNIQUE_IMPL_PTR(dataPtr)
  };
 
  class RenderSync;
 
  class GzRenderer
  {
    public: GzRenderer();
 
    public: void Render(RenderSync *_renderSync,
                        RenderThreadRhi &_renderThreadRhi);
 
    public: std::string Initialize(RenderThreadRhi &_rhi);
 
    public: void SetGraphicsAPI(const rendering::GraphicsAPI &_graphicsAPI);
 
    public: void Destroy();
 
    public: void NewMouseEvent(const common::MouseEvent &_e);
 
    public: void NewHoverEvent(const math::Vector2i &_hoverPos);
 
    public: void NewDropEvent(const std::string &_dropText,
      const math::Vector2i &_dropPos);
 
    public: void HandleKeyPress(const common::KeyEvent &_e);
 
    public: void HandleKeyRelease(const common::KeyEvent &_e);
 
    private: void HandleMouseEvent();
 
    private: void BroadcastHoverPos();
 
    private: void BroadcastDrag();
 
    private: void BroadcastLeftClick();
 
    private: void BroadcastRightClick();
 
    private: void BroadcastMousePress();
 
    private: void BroadcastScroll();
 
    private: void BroadcastKeyRelease();
 
    private: void BroadcastDrop();
 
    private: void BroadcastKeyPress();
 
    public: std::string engineName = "ogre";
 
    public: std::string sceneName = "scene";
 
    public: math::Pose3d cameraPose = math::Pose3d(0, 0, 2, 0, 0.4, 0);
 
    public: double cameraNearClip = 0.01;
 
    public: double cameraFarClip = 1000.0;
 
    public: math::Color backgroundColor = math::Color::Black;
 
    public: math::Color ambientLight = math::Color(0.3f, 0.3f, 0.3f, 1.0f);
 
    public: bool initialized = false;
 
    public: QSize textureSize = QSize(1024, 1024);
 
    public: bool textureDirty = true;
 
    public: bool skyEnable = false;
 
    public: std::optional<unsigned int> directionalLightTextureSize;
 
    public: math::Angle cameraHFOV = math::Angle(M_PI * 0.5);
 
    public: std::string cameraViewController{""};
 
    public: rendering::CameraPtr Camera();
 
    GZ_UTILS_UNIQUE_IMPL_PTR(dataPtr)
  };
 
  class RenderThread : public QThread
  {
    Q_OBJECT
 
    public: RenderThread();
 
    public slots: void RenderNext(gz::gui::plugins::RenderSync *_renderSync);
 
    public slots: void ShutDown();
 
    public slots: void SizeChanged();
 
    signals: void TextureReady(void* _texturePtr, const QSize &_size);
 
    public: void SetErrorCb(std::function<void(const QString &)> _cb);
 
    public: std::function<void(const QString &)> errorCb;
 
    public: QOffscreenSurface *Surface() const;
 
    public: void SetSurface(QOffscreenSurface *_surface);
 
    public: QOpenGLContext *Context() const;
 
    public: void SetContext(QOpenGLContext *_context);
 
    public: void SetGraphicsAPI(const rendering::GraphicsAPI &_graphicsAPI);
 
    public: std::string Initialize();
 
    public: GzRenderer gzRenderer;
 
    private: std::unique_ptr<RenderThreadRhi> rhi;
  };
 
  class RenderWindowItem : public QQuickItem
  {
    Q_OBJECT
 
    public: explicit RenderWindowItem(QQuickItem *_parent = nullptr);
 
    public: ~RenderWindowItem();
 
    public: void SetBackgroundColor(const math::Color &_color);
 
    public: void SetAmbientLight(const math::Color &_ambient);
 
    public: void SetEngineName(const std::string &_name);
 
    public: void SetSceneName(const std::string &_name);
 
    public: void SetCameraPose(const math::Pose3d &_pose);
 
    public: void SetCameraNearClip(double _near);
 
    public: void SetCameraFarClip(double _far);
 
    public: void OnHovered(const gz::math::Vector2i &_hoverPos);
 
    public: void OnDropped(const QString &_drop,
        const gz::math::Vector2i &_dropPos);
 
    public: void SetSkyEnabled(const bool &_sky);
 
    public: bool SetShadowTextureSize(rendering::LightType _lightType,
        unsigned int _textureSize);
 
    public: void SetCameraHFOV(const math::Angle &_fov);
 
    public: void SetGraphicsAPI(const rendering::GraphicsAPI& _graphicsAPI);
 
    public: void SetCameraViewController(const std::string &_view_controller);
 
    public Q_SLOTS: void Ready();
 
    public: void HandleKeyPress(const common::KeyEvent &_e);
 
    public: void HandleKeyRelease(const common::KeyEvent &_e);
 
    public: void SetErrorCb(std::function<void(const QString &)> _cb);
 
    public: void StopRendering();
 
    // Documentation inherited
    protected: virtual void mousePressEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: virtual void mouseReleaseEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: virtual void mouseMoveEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: virtual void keyPressEvent(QKeyEvent *_e) override;
 
    // Documentation inherited
    protected: virtual void keyReleaseEvent(QKeyEvent *_e) override;
 
    // Documentation inherited
    protected: virtual void wheelEvent(QWheelEvent *_e) override;
 
    private: QSGNode *updatePaintNode(QSGNode *_oldNode,
        QQuickItem::UpdatePaintNodeData *_data) override;
 
    GZ_UTILS_UNIQUE_IMPL_PTR(dataPtr)
  };
 
  class TextureNode : public QObject, public QSGSimpleTextureNode
  {
    Q_OBJECT
 
    public: explicit TextureNode(QQuickWindow *_window,
                                 RenderSync &_renderSync,
                                 const rendering::GraphicsAPI &_graphicsAPI,
                                 rendering::CameraPtr &_camera);
 
    public: ~TextureNode() override;
 
    // public slots: void NewTexture(uint _id, const QSize &_size);
    public slots: void NewTexture(void* _texturePtr, const QSize &_size);
 
    public slots: void PrepareNode();
 
          signals: void TextureInUse(gz::gui::plugins::RenderSync *_renderSync);
 
    signals: void PendingNewTexture();
 
    public: QSize size = QSize(0, 0);
 
    public: QMutex mutex;
 
    public: RenderSync &renderSync;
 
    public: QQuickWindow *window = nullptr;
 
    private: std::unique_ptr<TextureNodeRhi> rhi;
  };
}  // namespace gz::gui::plugins
 
#endif  // GZ_GUI_PLUGINS_MINIMALSCENE_HH_