Shape.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2018 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_PHYSICS_SHAPE_HH_
#define GZ_PHYSICS_SHAPE_HH_
 
#include <gz/physics/FeatureList.hh>
#include <gz/physics/FrameSemantics.hh>
#include <gz/physics/RelativeQuantity.hh>
#include <gz/physics/Geometry.hh>
 
namespace gz
{
  namespace physics
  {
    class GZ_PHYSICS_VISIBLE GetShapeKinematicProperties
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using PoseType =
            typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: PoseType GetRelativeTransform() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using PoseType =
            typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: virtual PoseType GetShapeRelativeTransform(
            const Identity &_shapeID) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetShapeKinematicProperties
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using PoseType =
            typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: void SetRelativeTransform(const PoseType &_pose);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using PoseType =
            typename FromPolicy<PolicyT>::template Use<Pose>;
 
        public: virtual void SetShapeRelativeTransform(
            const Identity &_shapeID, const PoseType &_pose) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE GetShapeCollisionProperties
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: Scalar GetFrictionCoefficient(
            const BaseShapePtr<PolicyT> &_other) const;
 
        public: Scalar GetRestitutionCoefficient(
            const BaseShapePtr<PolicyT> &_other) const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: virtual Scalar GetFrictionCoefficient(
            const Identity &_shape0, const Identity &_shape1) const = 0;
 
        public: virtual Scalar GetRestitutionCoefficient(
            const Identity &_shape0, const Identity &_shape1) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE GetShapeBoundingBox
        : public virtual FeatureWithRequirements<ShapeFrameSemantics>
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape
          : public virtual ShapeFrameSemantics::Shape<PolicyT, FeaturesT>
      {
        public: using AlignedBoxType =
            typename FromPolicy<PolicyT>::template Use<AlignedBox>;
 
        public: AlignedBoxType GetAxisAlignedBoundingBox(
            const FrameID &_referenceFrame = FrameID::World()) const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using AlignedBoxType =
            typename FromPolicy<PolicyT>::template Use<AlignedBox>;
 
        public: virtual AlignedBoxType GetShapeAxisAlignedBoundingBox(
            const Identity &_shape) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetShapeCollisionProperties
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: void SetFrictionCoefficient(
            const BaseShapePtr<PolicyT> &_other, Scalar _value);
 
        public: void SetRestitutionCoefficient(
            const BaseShapePtr<PolicyT> &_other, Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: virtual void SetShapeFrictionCoefficient(
            const Identity &_shape0,
            const Identity &_shape1,
            Scalar _value) = 0;
 
        public: virtual void SetShapeRestitutionCoefficient(
            const Identity &_shape0,
            const Identity &_shape1,
            Scalar _value) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE CollisionFilterMaskFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: void SetCollisionFilterMask(const uint16_t _mask);
 
        public: uint16_t GetCollisionFilterMask() const;
 
        public: void RemoveCollisionFilterMask();
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual void SetCollisionFilterMask(
            const Identity &_shapeID, const uint16_t _mask) = 0;
 
        public: virtual uint16_t GetCollisionFilterMask(
            const Identity &_shapeID) const = 0;
 
        public: virtual void RemoveCollisionFilterMask(
            const Identity &_shapeID) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE CategoryFilterMaskFeature
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: void SetCategoryFilterMask(const uint16_t _mask);
 
        public: uint16_t GetCategoryFilterMask() const;
 
        public: void RemoveCategoryFilterMask();
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: virtual void SetCategoryFilterMask(
            const Identity &_shapeID, const uint16_t _mask) = 0;
 
        public: virtual uint16_t GetCategoryFilterMask(
            const Identity &_shapeID) const = 0;
 
        public: virtual void RemoveCategoryFilterMask(
            const Identity &_shapeID) = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE GetShapeFrictionPyramidSlipCompliance
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: Scalar GetPrimarySlipCompliance() const;
 
        public: Scalar GetSecondarySlipCompliance() const;
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: virtual Scalar GetShapeFrictionPyramidPrimarySlipCompliance(
            const Identity &_shapeID) const = 0;
 
        public: virtual Scalar GetShapeFrictionPyramidSecondarySlipCompliance(
            const Identity &_shapeID) const = 0;
      };
    };
 
    class GZ_PHYSICS_VISIBLE SetShapeFrictionPyramidSlipCompliance
        : public virtual Feature
    {
      public: template <typename PolicyT, typename FeaturesT>
      class Shape : public virtual Feature::Shape<PolicyT, FeaturesT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: bool SetPrimarySlipCompliance(Scalar _value);
 
        public: bool SetSecondarySlipCompliance(Scalar _value);
      };
 
      public: template <typename PolicyT>
      class Implementation : public virtual Feature::Implementation<PolicyT>
      {
        public: using Scalar = typename PolicyT::Scalar;
 
        public: virtual bool SetShapeFrictionPyramidPrimarySlipCompliance(
            const Identity &_shapeID, Scalar _value) = 0;
 
        public: virtual bool SetShapeFrictionPyramidSecondarySlipCompliance(
            const Identity &_shapeID, Scalar _value) = 0;
      };
    };
  }
}
 
#include <gz/physics/detail/Shape.hh>
 
#endif