collision/broadphase-manager-base.hpp

Go to the documentation of this file.

//
// 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__