broadphase-manager-base.hpp

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

#pragma once
// IWYU pragma: begin_keep

#include "pinocchio/macros.hpp"

#include "pinocchio/multibody.hpp"

#include "pinocchio/collision/broadphase-callbacks.hpp"
// IWYU pragma: end_keep

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