gz/rendering/TransformController.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_RENDERING_TRANSFORMCONTROLLER_HH_
#define GZ_RENDERING_TRANSFORMCONTROLLER_HH_
 
#include <memory>
 
#include <gz/utils/SuppressWarning.hh>
 
#include <gz/math/Quaternion.hh>
#include <gz/math/Plane.hh>
#include <gz/math/Vector3.hh>
 
#include "gz/rendering/config.hh"
#include "gz/rendering/Camera.hh"
#include "gz/rendering/GizmoVisual.hh"
#include "gz/rendering/TransformType.hh"
 
namespace gz
{
  namespace rendering
  {
    inline namespace GZ_RENDERING_VERSION_NAMESPACE {
    //
    // forward declarations
    class TransformControllerPrivate;
 
    /* \class TransformController TransformController.hh \
     * gz/rendering/TransformController.hh
     */
    class GZ_RENDERING_VISIBLE TransformController
    {
      public: TransformController();
 
      public: virtual ~TransformController();
 
      public: virtual void Update();
 
      public: virtual void SetCamera(const CameraPtr &_camera);
 
      public: virtual CameraPtr Camera() const;
 
      public: virtual NodePtr Node() const;
 
      public: virtual void Attach(NodePtr _node);
 
      public: virtual void Detach();
 
      public: virtual void SetTransformMode(TransformMode _mode);
 
      public: virtual TransformMode Mode() const;
 
      public: virtual void SetTransformSpace(TransformSpace _space);
 
      public: virtual TransformSpace Space() const;
 
      public: virtual void SetActiveAxis(const math::Vector3d &_axis);
 
      public: virtual math::Vector3d ActiveAxis() const;
 
      public: virtual math::Vector3d AxisById(unsigned int _id) const;
 
      public: virtual void Translate(const math::Vector3d &_translation,
          bool _snap = false);
 
      public: virtual void Rotate(const math::Quaterniond &_rotation,
          bool _snap = false);
 
      public: virtual void Scale(const math::Vector3d &_scale,
          bool _snap = false);
 
      public: static gz::math::Vector3d SnapPoint(
          const gz::math::Vector3d &_point, const double _interval = 1.0,
          const double _sensitivity = 0.4);
 
      public: virtual void Start();
 
      public: virtual void Stop();
 
      public: virtual bool Active() const;
 
      public: math::Vector3d TranslationFrom2d(const math::Vector3d &_axis,
          const math::Vector2d &_start, const math::Vector2d &_end);
 
      public: math::Quaterniond RotationFrom2d(const math::Vector3d &_axis,
          const math::Vector2d &_start, const math::Vector2d &_end);
 
      public: math::Vector3d ScaleFrom2d(const math::Vector3d &_axis,
          const math::Vector2d &_start, const math::Vector2d &_end);
 
      public: static math::Vector3d ToAxis(TransformAxis _axis);
 
      protected: math::Planed CreatePlaneForTransform(
          const math::Vector3d &_axis, const math::Vector2d &_pt2d);
 
      protected: bool RayPlaneIntersection(RayQueryPtr _ray,
          const math::Planed &_plane, math::Vector3d &_result);
 
      GZ_UTILS_WARN_IGNORE__DLL_INTERFACE_MISSING
      public: std::unique_ptr<TransformControllerPrivate> dataPtr;
      GZ_UTILS_WARN_RESUME__DLL_INTERFACE_MISSING
    };
    }
  }
}
#endif