Scene3D.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2019 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_GAZEBO_GUI_SCENE3D_HH_
#define GZ_GAZEBO_GUI_SCENE3D_HH_
 
#include <gz/msgs/boolean.pb.h>
#include <gz/msgs/gui_camera.pb.h>
#include <gz/msgs/stringmsg.pb.h>
#include <gz/msgs/vector3d.pb.h>
#include <gz/msgs/video_record.pb.h>
 
#include <string>
#include <memory>
#include <mutex>
 
#include <sdf/Root.hh>
 
#include <gz/math/Color.hh>
#include <gz/math/Pose3.hh>
#include <gz/math/Vector2.hh>
#include <gz/math/Vector3.hh>
 
#include <gz/common/MouseEvent.hh>
#include <gz/common/KeyEvent.hh>
 
#include <gz/rendering/Camera.hh>
 
#include <gz/sim/gui/GuiSystem.hh>
 
#include "gz/gui/qt.h"
 
 
namespace ignition
{
namespace gazebo
{
// Inline bracket to help doxygen filtering.
inline namespace IGNITION_GAZEBO_VERSION_NAMESPACE {
  class IgnRendererPrivate;
  class RenderWindowItemPrivate;
  class Scene3DPrivate;
  class RenderUtil;
 
  class Scene3D : public ignition::gazebo::GuiSystem
  {
    Q_OBJECT
 
    Q_PROPERTY(
      QString errorPopupText
      READ ErrorPopupText
      WRITE SetErrorPopupText
      NOTIFY ErrorPopupTextChanged
    )
 
    
    Q_PROPERTY(
      QString loadingError
      READ LoadingError
      WRITE SetLoadingError
      NOTIFY LoadingErrorChanged
    )
 
    public: Scene3D();
 
    public: ~Scene3D() override;
 
    // Documentation inherited
    public: void LoadConfig(const tinyxml2::XMLElement *_pluginElem) override;
 
    // Documentation inherited
    public: void Update(const UpdateInfo &_info,
        EntityComponentManager &_ecm) override;
 
    public slots: void OnDropped(const QString &_drop,
        int _mouseX, int _mouseY);
 
    public slots: void OnHovered(int _mouseX, int _mouseY);
 
    public slots: void OnFocusWindow();
 
    // Documentation inherited
    protected: bool eventFilter(QObject *_obj, QEvent *_event) override;
 
    private: bool OnTransformMode(const msgs::StringMsg &_msg,
        msgs::Boolean &_res);
 
    private: bool OnRecordVideo(const msgs::VideoRecord &_msg,
        msgs::Boolean &_res);
 
    private: bool OnMoveTo(const msgs::StringMsg &_msg,
        msgs::Boolean &_res);
 
    private: bool OnFollow(const msgs::StringMsg &_msg,
        msgs::Boolean &_res);
 
    private: bool OnViewAngle(const msgs::Vector3d &_msg,
        msgs::Boolean &_res);
 
    private: bool OnMoveToPose(const msgs::GUICamera &_msg,
                 msgs::Boolean &_res);
 
    private: bool OnViewCollisions(const msgs::StringMsg &_msg,
        msgs::Boolean &_res);
 
    public: Q_INVOKABLE QString ErrorPopupText() const;
 
    public: Q_INVOKABLE void SetErrorPopupText(const QString &_errorTxt);
 
    signals: void ErrorPopupTextChanged();
 
    signals: void popupError();
 
    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 QObject
  {
    Q_OBJECT
 
    public: IgnRenderer();
 
    public: ~IgnRenderer() override;
 
    public: void Render();
 
    public: std::string Initialize();
 
    public: void Destroy();
 
    public: class RenderUtil *RenderUtil() const;
 
    public: void SetTransformMode(const std::string &_mode);
 
    public: void SetModel(const std::string &_model);
 
    public: void SetModelPath(const std::string &_filePath);
 
    public: void SetDropdownMenuEnabled(bool _enableDropdownMenu);
 
    public: void SetRecordVideo(bool _record, const std::string &_format,
        const std::string &_savePath);
 
    public: void SetRecordVideoUseSimTime(bool _useSimTime);
 
    public: void SetRecordVideoLockstep(bool _lockstep);
 
    public: void SetRecordVideoBitrate(unsigned int _bitrate);
 
    public: void SetMoveTo(const std::string &_target);
 
    public: void SetFollowTarget(const std::string &_target,
        bool _waitForTarget = false);
 
    public: void SetViewAngle(const math::Vector3d &_direction);
 
    public: void SetMoveToPose(const math::Pose3d &_pose);
 
    public: void SetViewCollisionsTarget(const std::string &_target);
 
    public: void SetFollowPGain(double _gain);
 
    public: void SetFollowWorldFrame(bool _worldFrame);
 
    public: void SetFollowOffset(const math::Vector3d &_offset);
 
    public: std::string FollowTarget() const;
 
    public: bool FollowWorldFrame() const;
 
    public: math::Vector3d FollowOffset() const;
 
    public: void SetInitCameraPose(const math::Pose3d &_pose);
 
    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);
 
    public: void SetXYZSnap(const math::Vector3d &_xyz);
 
    public: math::Vector3d XYZSnap() const;
 
    public: void SetRPYSnap(const math::Vector3d &_rpy);
 
    public: math::Vector3d RPYSnap() const;
 
    public: void SetScaleSnap(const math::Vector3d &_scale);
 
    public: math::Vector3d ScaleSnap() const;
 
    public: void SnapPoint(
                math::Vector3d &_point,
                math::Vector3d &_snapVals, double _sensitivity = 0.4) const;
 
    public: void RequestSelectionChange(Entity _selectedEntity,
        bool _deselectAll, bool _sendEvent);
 
    private: double SnapValue(
                 double _coord, double _interval, double _sensitivity) const;
 
    private: void XYZConstraint(math::Vector3d &_axis);
 
    private: void HandleMouseEvent();
 
    private: void HandleMouseContextMenu();
 
    private: void HandleMouseViewControl();
 
    private: void HandleMouseTransformControl();
 
    private: void HandleEntitySelection();
 
    private: void HandleModelPlacement();
 
    private: void BroadcastHoverPos();
 
    private: void BroadcastLeftClick();
 
    private: void BroadcastRightClick();
 
    private: Entity UniqueId();
 
    public: bool GeneratePreview(const sdf::Root &_sdf);
 
    public: void TerminateSpawnPreview();
 
    public: math::Vector3d ScreenToPlane(const math::Vector2i &_screenPos)
        const;
 
    public: math::Vector3d ScreenToScene(const math::Vector2i &_screenPos)
        const;
 
    public: math::Pose3d CameraPose() const;
 
    private: void OnMoveToComplete();
 
    private: void OnViewAngleComplete();
 
    private: void OnMoveToPoseComplete();
 
    private: void UpdateSelectedEntity(const rendering::NodePtr &_node,
        bool _sendEvent);
 
    private: void DeselectAllEntities(bool _sendEvent);
 
    signals: void ContextMenuRequested(QString _entity);
 
    signals: void FollowTargetChanged(const std::string &_target,
        bool _waitForTarget);
 
    public: GLuint textureId = 0u;
 
    public: math::Pose3d cameraPose = math::Pose3d(0, 0, 2, 0, 0.4, 0);
 
    public: std::string worldName;
 
    public: bool initialized = false;
 
    public: QSize textureSize = QSize(1024, 1024);
 
    public: bool textureDirty = false;
 
    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: ~RenderWindowItem() override;
 
    public: class RenderUtil *RenderUtil() const;
 
    public: void SetCameraPose(const math::Pose3d &_pose);
 
    public: math::Pose3d CameraPose() const;
 
    public: void SetInitCameraPose(const math::Pose3d &_pose);
 
    public: void SetTransformMode(const std::string &_mode);
 
    public: void SetModel(const std::string &_model);
 
    public: void SetModelPath(const std::string &_filePath);
 
    public: void SetDropdownMenuEnabled(bool _enableDropdownMenu);
 
    public: void SetRecordVideo(bool _record, const std::string &_format,
        const std::string &_savePath);
 
    public: void SetRecordVideoUseSimTime(bool _useSimTime);
 
    public: void SetRecordVideoLockstep(bool _lockstep);
 
    public: void SetRecordVideoBitrate(unsigned int _bitrate);
 
    public: void SetMoveTo(const std::string &_target);
 
    public Q_SLOTS: void SetFollowTarget(const std::string &_target,
        bool _waitForTarget = false);
 
    public: void SetViewAngle(const math::Vector3d &_direction);
 
    public: void SetMoveToPose(const math::Pose3d &_pose);
 
    public: void SetViewCollisionsTarget(const std::string &_target);
 
    public: void SetFollowPGain(double _gain);
 
    public: void SetFollowWorldFrame(bool _worldFrame);
 
    public: void SetFollowOffset(const math::Vector3d &_offset);
 
    public: void SetWorldName(const std::string &_name);
 
    public: void UpdateSelectedEntity(Entity _entity,
        bool _sendEvent);
 
    public: void DeselectAllEntities(bool _sendEvent);
 
    public: void SetXYZSnap(const math::Vector3d &_xyz);
 
    public: void SetRPYSnap(const math::Vector3d &_rpy);
 
    public: void SetScaleSnap(const math::Vector3d &_scale);
 
    public: math::Vector3d ScreenToScene(const math::Vector2i &_screenPos);
 
    public: void OnHovered(const gz::math::Vector2i &_hoverPos);
 
    public: bool RendererInitialized() const;
 
    public Q_SLOTS: void Ready();
 
    public: void HandleKeyPress(QKeyEvent *_e);
 
    public: void HandleKeyRelease(QKeyEvent *_e);
 
    // Documentation inherited
    protected: void mousePressEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: void mouseReleaseEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: void mouseMoveEvent(QMouseEvent *_e) override;
 
    // Documentation inherited
    protected: void wheelEvent(QWheelEvent *_e) override;
 
    private: QSGNode *updatePaintNode(QSGNode *_oldNode,
        QQuickItem::UpdatePaintNodeData *_data) override;
 
    signals: void openContextMenu(QString _entity); // NOLINT
 
    public slots: void OnContextMenuRequested(QString _entity);
 
    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