Scene3D.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 IGNITION_GUI_PLUGINS_SCENE3D_HH_
#define IGNITION_GUI_PLUGINS_SCENE3D_HH_

#include <string>
#include <memory>
#include <mutex>

#include <ignition/math/Color.hh>
#include <ignition/math/Pose3.hh>
#include <ignition/math/Vector2.hh>
#include <ignition/math/Vector3.hh>

#include <ignition/common/MouseEvent.hh>

#include "ignition/gui/qt.h"
#include "ignition/gui/Plugin.hh"

namespace ignition
{
namespace gui
{
namespace plugins
{
  class IgnRendererPrivate;
  class RenderWindowItemPrivate;
  class Scene3DPrivate;

  class Scene3D : public Plugin
  {
    Q_OBJECT

    Q_PROPERTY(
      QString loadingError
      READ LoadingError
      WRITE SetLoadingError
      NOTIFY LoadingErrorChanged
    )

    
    public: Scene3D();

    public: virtual ~Scene3D();

    public slots: void OnHovered(int _mouseX, int _mouseY);

    public slots: void OnFocusWindow();

    // Documentation inherited
    protected: bool eventFilter(QObject *_obj, QEvent *_event) override;

    // 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;

    private: std::unique_ptr<Scene3DPrivate> dataPtr;
  };

  class IgnRenderer
  {
    public: IgnRenderer();

    public: ~IgnRenderer();

    public: void Render();

    public: std::string Initialize();

    public: void Destroy();

    public: void NewMouseEvent(const common::MouseEvent &_e,
        const math::Vector2d &_drag = math::Vector2d::Zero);

    public: void NewHoverEvent(const math::Vector2i &_hoverPos);

    public: void HandleKeyPress(QKeyEvent *_e);

    public: void HandleKeyRelease(QKeyEvent *_e);

    private: void HandleMouseEvent();

    private: void HandleMouseViewControl();

    private: void BroadcastHoverPos();

    private: void BroadcastLeftClick();

    private: void BroadcastRightClick();

    private: void BroadcastKeyRelease();

    private: void BroadcastKeyPress();

    private: math::Vector3d ScreenToScene(const math::Vector2i &_screenPos)
        const;

    public: GLuint textureId = 0u;

    public: std::string engineName = "ogre";

    public: std::string sceneName = "scene";

    public: math::Pose3d cameraPose = math::Pose3d(0, 0, 2, 0, 0.4, 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 = false;

    public: std::string sceneService;

    public: std::string poseTopic;

    public: std::string deletionTopic;

    public: std::string sceneTopic;

    private: std::unique_ptr<IgnRendererPrivate> dataPtr;
  };

  class RenderThread : public QThread
  {
    Q_OBJECT

    public: RenderThread();

    public slots: void RenderNext();

    public slots: void ShutDown();

    public slots: void SizeChanged();

    signals: void TextureReady(int _id, const QSize &_size);

    public: void SetErrorCb(std::function<void(const QString &)> _cb);

    public: std::function<void(const QString &)> errorCb;

    public: QOffscreenSurface *surface = nullptr;

    public: QOpenGLContext *context = nullptr;

    public: IgnRenderer ignRenderer;
  };


  class RenderWindowItem : public QQuickItem
  {
    Q_OBJECT

    public: explicit RenderWindowItem(QQuickItem *_parent = nullptr);

    public: virtual ~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 SetSceneService(const std::string &_service);

    public: void SetPoseTopic(const std::string &_topic);

    public: void SetDeletionTopic(const std::string &_topic);

    public: void SetSceneTopic(const std::string &_topic);

    public: void OnHovered(const ignition::math::Vector2i &_hoverPos);

    public Q_SLOTS: void Ready();

    public: void HandleKeyPress(QKeyEvent *_e);

    public: void HandleKeyRelease(QKeyEvent *_e);

    // 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 wheelEvent(QWheelEvent *_e) override;

    // Documentation inherited
    protected: virtual void keyPressEvent(QKeyEvent *_event) override;

    // Documentation inherited
    protected: virtual void keyReleaseEvent(QKeyEvent *_event) override;

    private: QSGNode *updatePaintNode(QSGNode *_oldNode,
       QQuickItem::UpdatePaintNodeData *_data) override;

    public: void SetErrorCb(std::function<void(const QString &)> _cb);

    private: std::unique_ptr<RenderWindowItemPrivate> dataPtr;
  };

  class TextureNode : public QObject, public QSGSimpleTextureNode
  {
    Q_OBJECT

    public: explicit TextureNode(QQuickWindow *_window);

    public: ~TextureNode() override;

    public slots: void NewTexture(int _id, const QSize &_size);

    public slots: void PrepareNode();

    signals: void TextureInUse();

    signals: void PendingNewTexture();

    public: int id = 0;

    public: QSize size = QSize(0, 0);

    public: QMutex mutex;

    public: QSGTexture *texture = nullptr;

    public: QQuickWindow *window = nullptr;
  };
}
}
}

#endif