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 IGNITION_RENDERING_TRANSFORMCONTROLLER_HH_
#define IGNITION_RENDERING_TRANSFORMCONTROLLER_HH_

#include <memory>

#include <ignition/common/SuppressWarning.hh>

#include <ignition/math/Quaternion.hh>
#include <ignition/math/Plane.hh>
#include <ignition/math/Vector3.hh>

#include "ignition/rendering/config.hh"
#include "ignition/rendering/Camera.hh"
#include "ignition/rendering/GizmoVisual.hh"
#include "ignition/rendering/TransformType.hh"

namespace ignition
{
  namespace rendering
  {
    inline namespace IGNITION_RENDERING_VERSION_NAMESPACE {
    //
    // forward declarations
    class TransformControllerPrivate;

    /* \class TransformController TransformController.hh \
     * ignition/rendering/TransformController.hh
     */
    class IGNITION_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 ignition::math::Vector3d SnapPoint(
          const ignition::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);

      IGN_COMMON_WARN_IGNORE__DLL_INTERFACE_MISSING
      public: std::unique_ptr<TransformControllerPrivate> dataPtr;
      IGN_COMMON_WARN_RESUME__DLL_INTERFACE_MISSING
    };
    }
  }
}
#endif