collision_shapes.cpp

Go to the documentation of this file.

#include <stdio.h>

#include <btBulletCollisionCommon.h>

extern double bulletWorldScalingFactor;

extern "C"
{

  void deleteCollisionShape(btCollisionShape *ptr)
  {
    delete ptr;
  }

  int getShapeType(btCollisionShape *ptr)
  {
    return ptr->getShapeType();
  }
  
  btCollisionShape *newBoxShape(const double *half_extents)
  {
    return new btBoxShape(btVector3(half_extents[0] * bulletWorldScalingFactor,
        half_extents[1] * bulletWorldScalingFactor,
        half_extents[2] * bulletWorldScalingFactor));
  }

  bool isBoxShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btBoxShape *>(ptr) != NULL;
  }

  void getBoxHalfExtents(const btBoxShape *box, double *half_extents)
  {
    btVector3 extents = box->getHalfExtentsWithMargin() / bulletWorldScalingFactor;
    half_extents[0] = extents.x();
    half_extents[1] = extents.y();
    half_extents[2] = extents.z();
  }

  btCollisionShape *newStaticPlaneShape(const double *normal, double constant)
  {
    return new btStaticPlaneShape(btVector3(normal[0], normal[1], normal[2]), constant);
  }

  bool isStaticPlaneShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btStaticPlaneShape *>(ptr) != NULL;
  }

  void getPlaneNormal(const btStaticPlaneShape *plane, double *normal)
  {
    btVector3 normal_vec = plane->getPlaneNormal();
    normal[0] = normal_vec.x();
    normal[1] = normal_vec.y();
    normal[2] = normal_vec.z();
  }

  double getPlaneConstant(const btStaticPlaneShape *plane)
  {
    return plane->getPlaneConstant();
  }
  
  btCollisionShape *newSphereShape(double radius)
  {
    return new btSphereShape(radius * bulletWorldScalingFactor);
  }

  bool isSphereShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btSphereShape *>(ptr) != NULL;
  }

  double getSphereRadius(const btSphereShape *sphere)
  {
    return sphere->getRadius() / bulletWorldScalingFactor;
  }

  btCollisionShape *newCylinderShape(const double *half_extents)
  {
    return new btCylinderShapeZ(
      btVector3(
        half_extents[0] * bulletWorldScalingFactor,
        half_extents[1] * bulletWorldScalingFactor,
        half_extents[2] * bulletWorldScalingFactor));
  }

  bool isCylinderShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btCylinderShape *>(ptr) != NULL;
  }

  void getCylinderHalfExtents(const btCylinderShape *cylinder, double *half_extents)
  {
    btVector3 extents = cylinder->getHalfExtentsWithMargin() / bulletWorldScalingFactor;
    half_extents[0] = extents.x();
    half_extents[1] = extents.y();
    half_extents[2] = extents.z();
  }
  
  btCollisionShape *newConeShape(double radius, double height)
  {
    return new btConeShapeZ(
      radius * bulletWorldScalingFactor,
      height * bulletWorldScalingFactor);
  }

  bool isConeShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btConeShape *>(ptr) != NULL;
  }

  double getConeRadius(const btConeShape *cone)
  {
    return cone->getRadius() / bulletWorldScalingFactor;
  }

  double getConeHeight(const btConeShape *cone)
  {
    return cone->getHeight() / bulletWorldScalingFactor;
  }

  btCollisionShape *newCompoundShape()
  {
    return new btCompoundShape();
  }

  bool isCompoundShape(const btCompoundShape *ptr)
  {
    return dynamic_cast<const btCompoundShape *>(ptr) != NULL;
  }

  void addChildShape(btCompoundShape *parent,
    const double *position, const double *orientation,
    btCollisionShape *shape)
  {
    parent->addChildShape(
      btTransform(
        btQuaternion(orientation[0],
          orientation[1],
          orientation[2],
          orientation[3]),
        btVector3(position[0] * bulletWorldScalingFactor,
          position[1] * bulletWorldScalingFactor,
          position[2] * bulletWorldScalingFactor)),
      shape);
  }

  int getNumChildShapes(btCompoundShape *shape)
  {
    return shape->getNumChildShapes();
  }

  const btCollisionShape *getChildShape(const btCompoundShape *shape, int index)
  {
    return shape->getChildShape(index);
  }

  void getChildTransform(const btCompoundShape *shape, int index, double *transform)
  {
    const btTransform &trans = shape->getChildTransform(index);
    const btVector3 &pos = trans.getOrigin() / bulletWorldScalingFactor;
    btQuaternion rot = trans.getRotation();
    transform[0] = pos.x();
    transform[1] = pos.y();
    transform[2] = pos.z();
    transform[3] = rot.x();
    transform[4] = rot.y();
    transform[5] = rot.z();
    transform[6] = rot.w();
  }

  btCollisionShape *newConvexHullShape(const double *points, int num_points)
  {
    double *scaled_points = new double[num_points*3];
    for(int i=0; i<num_points*3; i++)
      scaled_points[i] = points[i] * bulletWorldScalingFactor;
    return new btConvexHullShape(scaled_points, num_points, sizeof(double) * 3);
    delete scaled_points;
  }

  bool isConvexHullShape(const btCollisionShape *ptr)
  {
    return dynamic_cast<const btConvexHullShape *>(ptr) != NULL;
  }

  void addPoint(btConvexHullShape *shape, const double *point)
  {
    shape->addPoint(btVector3(point[0] * bulletWorldScalingFactor,
        point[1] * bulletWorldScalingFactor, point[2] * bulletWorldScalingFactor));
  }

  int convexHullGetNumPoints(const btConvexHullShape *shape)
  {
    return shape->getNumPoints();
  }

  void getPoint(const btConvexHullShape *shape, int index, double *point)
  {
    const btVector3 &pt = shape->getUnscaledPoints()[index] / bulletWorldScalingFactor;
    point[0] = pt.x();
    point[1] = pt.y();
    point[2] = pt.z();
  }
}