Program Listing for File broadphase-manager-base.hpp

Return to documentation for file (include/pinocchio/collision/broadphase-manager-base.hpp)

//
// Copyright (c) 2022 INRIA
//

#ifndef __pinocchio_collision_broadphase_manager_base_hpp__
#define __pinocchio_collision_broadphase_manager_base_hpp__

#include "pinocchio/multibody/geometry.hpp"
#include "pinocchio/collision/broadphase-callbacks.hpp"

namespace pinocchio
{

  template<typename Derived>
  struct BroadPhaseManagerBase
  {
    BroadPhaseManagerBase() // for std::vector
    : model_ptr(nullptr)
    , geometry_model_ptr(nullptr)
    , geometry_data_ptr(nullptr)
    {
    }

    BroadPhaseManagerBase(
      const Model * model_ptr,
      const GeometryModel * geometry_model_ptr,
      GeometryData * geometry_data_ptr)
    : model_ptr(model_ptr)
    , geometry_model_ptr(geometry_model_ptr)
    , geometry_data_ptr(geometry_data_ptr)
    {
    }

    BroadPhaseManagerBase(const BroadPhaseManagerBase & other)
    : model_ptr(other.model_ptr)
    , geometry_model_ptr(other.geometry_model_ptr)
    , geometry_data_ptr(other.geometry_data_ptr)
    {
    }

    BroadPhaseManagerBase &
    operator=(const BroadPhaseManagerBase & other) // Copy assignment operator
    {
      model_ptr = other.model_ptr;
      geometry_model_ptr = other.geometry_model_ptr;
      geometry_data_ptr = other.geometry_data_ptr;
      return *this;
    }

    Derived & derived()
    {
      return static_cast<Derived &>(*this);
    }
    const Derived & derived() const
    {
      return static_cast<const Derived &>(*this);
    }

    bool check() const
    {
      return derived().check();
    }

    bool check(CollisionCallBackBase * callback) const
    {
      return derived().check(callback);
    }

    void update(bool compute_local_aabb = false)
    {
      derived().update(compute_local_aabb);
    }

    void update(GeometryData * geom_data_ptr_new)
    {
      derived().update(geom_data_ptr_new);
    }

    bool collide(CollisionObject & obj, CollisionCallBackBase * callback) const
    {
      return derived().collide(obj, callback);
    }

    bool collide(CollisionCallBackBase * callback) const
    {
      return derived().collide(callback);
    }

    bool collide(BroadPhaseManagerBase & other_manager, CollisionCallBackBase * callback) const
    {
      return derived().collide(other_manager.derived(), callback);
    }

    //  /// @brief Performs distance computation between one object and all the objects belonging to
    //  the manager void distance(CollisionObject* obj, DistanceCallBackBase * callback) const;

    //  /// @brief Performs distance test for the objects belonging to the manager (i.e., N^2 self
    //  distance) void distance(DistanceCallBackBase * callback) const;

    //  /// @brief Performs distance test with objects belonging to another manager
    //  void distance(BroadPhaseCollisionManager* other_manager, DistanceCallBackBase * callback)
    //  const;

    const Model & getModel() const
    {
      return *model_ptr;
    }

    const GeometryModel & getGeometryModel() const
    {
      return *geometry_model_ptr;
    }

    const GeometryData & getGeometryData() const
    {
      return *geometry_data_ptr;
    }

    GeometryData & getGeometryData()
    {
      return *geometry_data_ptr;
    }

  protected:
    const Model * model_ptr;

    const GeometryModel * geometry_model_ptr;

    GeometryData * geometry_data_ptr;

  }; // struct BroadPhaseManagerBase<Derived>

} // namespace pinocchio

#endif // ifndef __pinocchio_collision_broadphase_manager_base_hpp__