rapier.h

Go to the documentation of this file.

#if !defined(RAPIER_DIM2) && !defined(RAPIER_DIM3)
#define RAPIER_DIM3
#endif
#if defined(RAPIER_DIM2) && defined(RAPIER_DIM3)
#error Select exactly one Rapier dimension
#endif
#if !defined(RAPIER_F32) && !defined(RAPIER_F64)
#define RAPIER_F32
#endif
#if defined(RAPIER_F32) && defined(RAPIER_F64)
#error Select exactly one Rapier precision
#endif
#if defined(RAPIER_DIM2)
#define R2_DIMENSION 2
#define RAPIER_TYPE(name) R2##name
#define RAPIER_CONST(name) R2_##name
#define RAPIER_FN(name) r2##name
#else
#define R3_DIMENSION 3
#define RAPIER_TYPE(name) R3##name
#define RAPIER_CONST(name) R3_##name
#define RAPIER_FN(name) r3##name
#endif
#if defined(_WIN32)
#define RAPIER_CALL __cdecl
#else
#define RAPIER_CALL
#endif
#ifndef RAPIER_API
#if defined(_WIN32) && !defined(RAPIER_STATIC)
#define RAPIER_API __declspec(dllimport)
#else
#define RAPIER_API
#endif
#endif
 
 
#ifndef RAPIER_H
#define RAPIER_H
 
/* Generated by cbindgen. Regenerate with bindings/c/tools/generate-header.sh. */
 
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
 
#if defined(RAPIER_DIM2)
 
#if defined(RAPIER_DIM3)
#define R2_FRICTION_MODEL_SIMPLIFIED 0
#endif
 
#if defined(RAPIER_DIM3)
#define R2_FRICTION_MODEL_COULOMB 1
#endif
 
#if defined(RAPIER_DIM2)
#define R2_JOINT_DOF_COUNT 3
#endif
 
#if defined(RAPIER_DIM3)
#define R2_JOINT_DOF_COUNT 6
#endif

#define R2_SOFT_DESC_PARTICLES 0

#define R2_SOFT_DESC_ROPE 1

#define R2_SOFT_DESC_GRID 2

#define R2_SOFT_DESC_CLOTH 3

#define R2_SOFT_DESC_CUBOID 4

#define R2_SOFT_DESC_SURFACE 5

#define R2_SOFT_DESC_DISK 6

#define R2_SOFT_DESC_SPHERE 7

#define R2_SOFT_DESC_CLOTH_TUBE 8

#define R2_SOFT_DESC_VOLUMETRIC 9
 
#if defined(RAPIER_DIM2)
#define R2_SOFT_DESC_POLYGON 10
#endif
 
#if defined(RAPIER_DIM2)
#define R2_SOFT_DESC_TRIMESH 11
#endif
 
#if defined(RAPIER_DIM3)
#define R2_SOFT_DESC_CLOTH_ANISOTROPIC 12
#endif

#define R2_SOFT_BINDING_SKINNED 0

#define R2_SOFT_BINDING_DIRECT 1

#define R2_SOFT_BINDING_DIRECT_BY_POSITION 2
 
#if defined(RAPIER_DIM2)
#define R2_POLYLINE_ORIENTED 1
#endif

#define R2_POLYLINE_DEFORMABLE 2

#define R2_SHAPE_DESC_BALL 0

#define R2_SHAPE_DESC_CUBOID 1

#define R2_SHAPE_DESC_ROUND_CUBOID 2

#define R2_SHAPE_DESC_CAPSULE 3

#define R2_SHAPE_DESC_SEGMENT 4

#define R2_SHAPE_DESC_TRIANGLE 5

#define R2_SHAPE_DESC_HALFSPACE 6

#define R2_SHAPE_DESC_CONVEX_HULL 7

#define R2_SHAPE_DESC_TRIMESH 8

#define R2_SHAPE_DESC_POLYLINE 9

#define R2_SHAPE_DESC_SHARED 10

#define R2_SHAPE_DESC_HEIGHTFIELD 11

#define R2_SHAPE_DESC_CYLINDER 12

#define R2_SHAPE_DESC_CONE 13

#define R2_SHAPE_DESC_COMPOUND 14

#define R2_SHAPE_DESC_ROUND_CYLINDER 15

#define R2_SHAPE_DESC_ROUND_CONE 16

#define R2_MASS_DENSITY 0

#define R2_MASS_TOTAL 1

#define R2_MASS_PROPERTIES 2

#define R2_ABI_VERSION 1

#define R2_DYNAMIC 0

#define R2_FIXED 1

#define R2_KINEMATIC_POSITION_BASED 2

#define R2_KINEMATIC_VELOCITY_BASED 3

#define R2_COLLISION_EVENTS 1

#define R2_CONTACT_FORCE_EVENTS 2

#define R2_COMBINE_AVERAGE 0

#define R2_COMBINE_MIN 1

#define R2_COMBINE_MULTIPLY 2

#define R2_COMBINE_MAX 3

#define R2_COMBINE_CLAMPED_SUM 4

#define R2_COMBINE_GEOMETRIC_MEAN 5

#define R2_COLLISION_TYPES_DYNAMIC_DYNAMIC 1

#define R2_COLLISION_TYPES_DYNAMIC_KINEMATIC 12

#define R2_COLLISION_TYPES_DYNAMIC_FIXED 2

#define R2_COLLISION_TYPES_KINEMATIC_KINEMATIC 52224

#define R2_COLLISION_TYPES_KINEMATIC_FIXED 8704

#define R2_COLLISION_TYPES_FIXED_FIXED 32

#define R2_COLLISION_TYPES_DEFAULT 15

#define R2_FILTER_CONTACT_PAIRS 1

#define R2_FILTER_INTERSECTION_PAIR 2

#define R2_MODIFY_SOLVER_CONTACTS 4

#define R2_QUERY_EXCLUDE_FIXED 1

#define R2_QUERY_EXCLUDE_KINEMATIC 2

#define R2_QUERY_EXCLUDE_DYNAMIC 4

#define R2_QUERY_EXCLUDE_SENSORS 8

#define R2_QUERY_EXCLUDE_SOLIDS 16

#define R2_QUERY_ONLY_DYNAMIC 3

#define R2_QUERY_ONLY_KINEMATIC 5

#define R2_QUERY_ONLY_FIXED 6

#define R2_DEBUG_COLLIDER_SHAPES 1

#define R2_DEBUG_RIGID_BODY_AXES 2

#define R2_DEBUG_MULTIBODY_JOINTS 4

#define R2_DEBUG_IMPULSE_JOINTS 8

#define R2_DEBUG_SOLVER_CONTACTS 16

#define R2_DEBUG_CONTACTS 32

#define R2_DEBUG_COLLIDER_AABBS 64

#define R2_DEBUG_SOFT_BODIES 128

#define R2_DEBUG_PSEUDO_NORMALS 256

#define R2_DEBUG_SOFT_VOLUME_CONTACTS 512

#define R2_DEBUG_SOFT_BODY_STRESS 1024

#define R2_GROUPS_AND 0

#define R2_GROUPS_OR 1

#define R2_MOTOR_ACCELERATION_BASED 0

#define R2_MOTOR_FORCE_BASED 1

#define R2_SOFT_CELL_VOLUME 0

#define R2_SOFT_CELL_COROTATIONAL 1

#define R2_SOFT_CELL_NEO_HOOKEAN 2

#define R2_SOFT_SOLVER_CONSTRAINTS 0

#define R2_SOFT_SOLVER_FEM 1

#define R2_SOFT_EDGE_PLASTIC_FLOW_BOTH 0

#define R2_SOFT_EDGE_PLASTIC_FLOW_COMPRESSION 1

#define R2_SOFT_EDGE_PLASTIC_FLOW_TENSION 2

#define R2_SOFT_PATCH_CONSTRAINTS_KEEP 0

#define R2_SOFT_PATCH_CONSTRAINTS_STAND_DOWN 1

#define R2_SOFT_PATCH_CONSTRAINTS_ALONG_NORMAL 2

#define R2_AXIS_LIN_X 0

#define R2_AXIS_LIN_Y 1

#define R2_LOCK_TRANSLATION_X 1

#define R2_LOCK_TRANSLATION_Y 2

#define R2_LOCK_TRANSLATION_Z 4

#define R2_LOCK_ROTATION_X 8

#define R2_LOCK_ROTATION_Y 16

#define R2_LOCK_ROTATION_Z 32
 
#if defined(RAPIER_DIM2)
#define R2_AXIS_ANG_X 2
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXIS_ANG_X 3
#endif
 
#if defined(RAPIER_DIM2)
#define R2_JOINT_FIXED_AXES 7
#endif
 
#if defined(RAPIER_DIM3)
#define R2_JOINT_FIXED_AXES 63
#endif
 
#if defined(RAPIER_DIM2)
#define R2_JOINT_REVOLUTE_AXES 3
#endif
 
#if defined(RAPIER_DIM3)
#define R2_JOINT_REVOLUTE_AXES 55
#endif
 
#if defined(RAPIER_DIM2)
#define R2_JOINT_PRISMATIC_AXES 6
#endif
 
#if defined(RAPIER_DIM3)
#define R2_JOINT_PRISMATIC_AXES 62
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXIS_LIN_Z 2
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXIS_ANG_Y 4
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXIS_ANG_Z 5
#endif
 
#if defined(RAPIER_DIM3)
#define R2_JOINT_SPHERICAL_AXES 7
#endif

#define R2_SOFT_FRAME 4

#define R2_SHAPE_CAST_OUT_OF_ITERATIONS 0

#define R2_SHAPE_CAST_CONVERGED 1

#define R2_SHAPE_CAST_FAILED 2

#define R2_SHAPE_CAST_PENETRATING 3

#define R2_FEATURE_UNKNOWN 0

#define R2_FEATURE_VERTEX 1

#define R2_FEATURE_EDGE 2

#define R2_FEATURE_FACE 3

#define R2_MULTIBODY_JOINTS_ARE_KINEMATIC 1

#define R2_MULTIBODY_DISABLE_SELF_CONTACTS 2

#define R2_MULTIBODY_SKIP_LOOP_CLOSURES 4

#define R2_MULTIBODY_SKIP_JOINT_MOTORS 8

#define R2_MULTIBODY_SKIP_JOINT_LIMITS 16

#define R2_MULTIBODY_SKIP_JOINT_SPRINGS 32

#define R2_TRIMESH_HALF_EDGE_TOPOLOGY 1

#define R2_TRIMESH_CONNECTED_COMPONENTS 2

#define R2_TRIMESH_DELETE_BAD_TOPOLOGY_TRIANGLES 4

#define R2_TRIMESH_ORIENTED 8

#define R2_TRIMESH_MERGE_DUPLICATE_VERTICES 16

#define R2_TRIMESH_DELETE_DEGENERATE_TRIANGLES 32

#define R2_TRIMESH_DELETE_DUPLICATE_TRIANGLES 64

#define R2_TRIMESH_FIX_INTERNAL_EDGES 144

#define R2_TRIMESH_DEFORMABLE 256

#define R2_TRIMESH_FIX_INTERNAL_EDGES_TWO_SIDED 656

#define R2_HEIGHTFIELD_FIX_INTERNAL_EDGES 1

#define R2_AXES_MASK_LIN_X 1

#define R2_AXES_MASK_LIN_Y 2
 
#if defined(RAPIER_DIM3)
#define R2_AXES_MASK_LIN_Z 4
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXES_MASK_ANG_X 8
#endif
 
#if defined(RAPIER_DIM3)
#define R2_AXES_MASK_ANG_Y 16
#endif

#define R2_AXES_MASK_ANG_Z 32

#define R2_ABI_FEATURE_FEM 1

#define R2_ABI_FEATURE_ROBOTICS 2
 
#if (defined(RAPIER_FEM) && defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_ABI_FEATURES 3
#endif
 
#if (defined(RAPIER_FEM) && !(defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32)))
#define R2_ABI_FEATURES 1
#endif
 
#if (!defined(RAPIER_FEM) && defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_ABI_FEATURES 2
#endif
 
#if (!defined(RAPIER_FEM) && !(defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32)))
#define R2_ABI_FEATURES 0
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_MESH_CONVERTER_TRIMESH 0
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_MESH_CONVERTER_OBB 1
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_MESH_CONVERTER_AABB 2
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_MESH_CONVERTER_CONVEX_HULL 3
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R2_MESH_CONVERTER_CONVEX_DECOMPOSITION 4
#endif

#define R2_COLLISION_EVENT_SENSOR 1

#define R2_COLLISION_EVENT_REMOVED 2

typedef struct R2Bytes R2Bytes;

typedef struct R2ContactModificationContext R2ContactModificationContext;
 
#if defined(RAPIER_DIM3)
typedef struct R2DynamicRayCastVehicleController R2DynamicRayCastVehicleController;
#endif

typedef struct R2EventCollector R2EventCollector;

typedef struct R2KinematicCharacterController R2KinematicCharacterController;
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2LoadedMeshes R2LoadedMeshes;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfContactHooks R2MjcfContactHooks;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfRobot R2MjcfRobot;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfRobotHandles R2MjcfRobotHandles;
#endif

typedef struct R2PidController R2PidController;

typedef struct R2ReadContext R2ReadContext;

typedef struct R2ShapeMesh R2ShapeMesh;

typedef struct R2SoftBodyTearEvent R2SoftBodyTearEvent;
 
#if defined(RAPIER_DIM3)
typedef struct R2TriMeshData R2TriMeshData;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2UrdfRobot R2UrdfRobot;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2UrdfRobotHandles R2UrdfRobotHandles;
#endif

typedef struct R2World R2World;
 
#if defined(RAPIER_F32)
typedef float R2Real;
#endif
 
#if defined(RAPIER_F64)
typedef double R2Real;
#endif

typedef struct R2SpringCoefficients {
  R2Real natural_frequency;
  R2Real damping_ratio;
} R2SpringCoefficients;

typedef uint32_t R2Bool;

typedef struct R2OptionalReal {
  R2Bool enabled;
  R2Real value;
} R2OptionalReal;

typedef struct R2OptionalU32 {
  R2Bool enabled;
  uint32_t value;
} R2OptionalU32;

typedef struct R2SoftBodyMaterial {
  struct R2SpringCoefficients edgeSoftness;
  struct R2SpringCoefficients bendSoftness;
  struct R2SpringCoefficients volumeSoftness;
  struct R2SpringCoefficients shapeMatchingSoftness;
  R2Real youngModulus;
  R2Real poissonRatio;
  R2Real elasticDampingRatio;
  R2Real plasticYield;
  R2Real plasticCreep;
  R2Real plasticMax;
  R2Real deformationDamping;
  R2Real edgePlasticYield;
  R2Real edgePlasticCreep;
  R2Real edgePlasticMax;
  uint32_t edgePlasticFlow;
  struct R2OptionalReal tearStrain;
  struct R2OptionalReal tearForce;
  R2Real tearSmoothing;
  R2Real interiorStrength;
  uint32_t maxTearsPerStep;
  struct R2OptionalU32 minPiece;
} R2SoftBodyMaterial;

typedef struct R2SoftRecoverySettings {
  R2Bool authoredVelocityMargin;
  R2Bool edgeSpeculation;
  R2Bool invertedCellDetection;
  R2Bool selfCrossingDetection;
  R2Bool detectionMotionGating;
  R2Bool crossBodyDetection;
  R2Bool selfStandDown;
  R2Bool crossBodyExpelGate;
  R2Bool edgeStandDown;
  R2Bool crossingRepulsion;
  R2Bool crossingRepulsionGuide;
  R2Bool crossingRepulsionSelfGuide;
  R2Real recoveryPace;
  R2Bool overlapConstraints;
  R2Bool overlapRigid;
  R2Bool overlapSkipSelfTangled;
  R2Bool overlapEdgeStandDown;
  R2Real overlapConstraintPace;
  uint32_t overlapPatchConstraints;
  R2Bool overlapSkinVolume;
  R2Real overlapKeptDepth;
  R2Bool overlapSelfRegions;
  R2Bool overlapNormalPush;
  R2Bool overlapMultiVolume;
  uint32_t overlapSplit;
  uint32_t overlapPatience;
  R2Real overlapProgressMargin;
} R2SoftRecoverySettings;
 
#if defined(RAPIER_FEM)
typedef struct R2SoftFemParameters {
  R2Real linearTolerance;
  size_t maxLinearIterations;
  size_t maxDenseDofs;
} R2SoftFemParameters;
#endif

typedef struct R2SoftBodiesSettings {
  struct R2SoftRecoverySettings recovery;
  R2Real resweepStrain;
  size_t maxExtraSubsteps;
  R2Real contactStiffening;
#if defined(RAPIER_FEM)
  struct R2SoftFemParameters fem;
#endif
} R2SoftBodiesSettings;

typedef struct R2IntegrationParameters {
  R2Real dt;
  R2Real minCcdDt;
  struct R2SpringCoefficients contactSoftness;
  struct R2SpringCoefficients staticContactSoftness;
  R2Real warmstartCoefficient;
  R2Real lengthUnit;
  struct R2SoftBodiesSettings softBodies;
  R2Real normalizedAllowedLinearError;
  R2Real normalizedMaxCorrectiveVelocity;
  R2Real normalizedPredictionDistance;
  R2Real normalizedMaxLinearVelocity;
  size_t numSolverIterations;
  size_t numInternalPgsIterations;
  size_t numInternalStabilizationIterations;
  size_t maxCcdSubsteps;
  R2Bool contactClustering;
  R2Bool contactRecycling;
  R2Real normalizedContactRecycleDistance;
  R2Bool frictionInBiasPass;
  R2Bool warmstartJoints;
#if defined(RAPIER_DIM3)
  uint32_t frictionModel;
#endif
} R2IntegrationParameters;

typedef uint32_t R2Status;

typedef struct R2Vector {
  R2Real x;
  R2Real y;
#if defined(RAPIER_DIM3)
  R2Real z;
#endif
} R2Vector;

typedef struct R2Rotation {
#if defined(RAPIER_DIM2)
  R2Real angle;
#endif
#if defined(RAPIER_DIM3)
  R2Real x;
#endif
#if defined(RAPIER_DIM3)
  R2Real y;
#endif
#if defined(RAPIER_DIM3)
  R2Real z;
#endif
#if defined(RAPIER_DIM3)
  R2Real w;
#endif
} R2Rotation;

typedef struct R2Pose {
  struct R2Vector translation;
  struct R2Rotation rotation;
} R2Pose;

typedef struct R2JointLimits {
  R2Real min;
  R2Real max;
} R2JointLimits;

typedef struct R2JointMotor {
  R2Real targetVel;
  R2Real targetPos;
  R2Real stiffness;
  R2Real damping;
  R2Real maxForce;
  uint32_t model;
} R2JointMotor;

typedef struct R2UserData {
  uint64_t low;
  uint64_t high;
} R2UserData;

typedef struct R2JointDesc {
  struct R2Pose localFrame1;
  struct R2Pose localFrame2;
  uint8_t lockedAxes;
  uint8_t limitAxes;
  uint8_t motorAxes;
  uint8_t coupledAxes;
  struct R2JointLimits limits[R2_JOINT_DOF_COUNT];
  struct R2JointMotor motors[R2_JOINT_DOF_COUNT];
  struct R2SpringCoefficients softness;
  R2Bool contactsEnabled;
  R2Bool enabled;
  struct R2UserData userData;
} R2JointDesc;

typedef struct R2ImpulseJointHandle {
  struct R2World *world;
  uint32_t index;
  uint32_t generation;
} R2ImpulseJointHandle;

typedef struct R2RigidBodyHandle {
  struct R2World *world;
  uint32_t index;
  uint32_t generation;
} R2RigidBodyHandle;

typedef struct R2MultibodyJointHandle {
  struct R2World *world;
  uint32_t index;
  uint32_t generation;
} R2MultibodyJointHandle;

typedef struct R2VolumeMeshParameters {
  R2Real cell_size;
#if defined(RAPIER_DIM2)
  R2Real min_angle;
#endif
#if defined(RAPIER_DIM3)
  uint32_t enclosure;
#endif
#if defined(RAPIER_DIM3)
  uint32_t cover_smoothing;
#endif
#if defined(RAPIER_DIM3)
  R2Real cover_guard;
#endif
#if defined(RAPIER_DIM3)
  uint32_t cover_subdivisions;
#endif
} R2VolumeMeshParameters;

typedef struct R2VectorView {
  const struct R2Vector *data;
  size_t count;
} R2VectorView;

typedef struct R2RealView {
  const R2Real *data;
  size_t count;
} R2RealView;

typedef struct R2IndexView {
  const uint32_t *data;
  size_t count;
} R2IndexView;

typedef struct R2Edge {
  uint32_t a;
  uint32_t b;
} R2Edge;

typedef struct R2EdgeView {
  const struct R2Edge *data;
  size_t count;
} R2EdgeView;

typedef struct R2SoftEdgeSoftness {
  uint32_t edge;
  struct R2SpringCoefficients softness;
} R2SoftEdgeSoftness;

typedef struct R2SoftEdgeSoftnessView {
  const struct R2SoftEdgeSoftness *data;
  size_t count;
} R2SoftEdgeSoftnessView;

typedef struct R2SoftEdgeTear {
  uint32_t edge;
  R2Real resistance;
} R2SoftEdgeTear;

typedef struct R2SoftEdgeTearView {
  const struct R2SoftEdgeTear *data;
  size_t count;
} R2SoftEdgeTearView;

typedef struct R2Triangle {
  uint32_t a;
  uint32_t b;
  uint32_t c;
} R2Triangle;

typedef struct R2TriangleView {
  const struct R2Triangle *data;
  size_t count;
} R2TriangleView;

typedef struct R2Tetrahedron {
  uint32_t a;
  uint32_t b;
  uint32_t c;
  uint32_t d;
} R2Tetrahedron;

typedef struct R2TetrahedronView {
  const struct R2Tetrahedron *data;
  size_t count;
} R2TetrahedronView;
 
#if defined(RAPIER_DIM2)
typedef struct R2TriangleView R2CellView;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R2TetrahedronView R2CellView;
#endif
 
#if defined(RAPIER_DIM2)
typedef struct R2EdgeView R2SurfaceElementView;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R2TriangleView R2SurfaceElementView;
#endif

typedef struct R2Dihedral {
  uint32_t a;
  uint32_t b;
  uint32_t c;
  uint32_t d;
} R2Dihedral;

typedef struct R2DihedralView {
  const struct R2Dihedral *data;
  size_t count;
} R2DihedralView;

typedef struct R2SoftBodyDescView {
  const struct R2SoftBodyDesc *data;
  size_t count;
} R2SoftBodyDescView;

typedef struct R2OptionalBool {
  R2Bool enabled;
  R2Bool value;
} R2OptionalBool;

typedef struct R2SharedShape R2SharedShape;
 

typedef struct R2CompoundShapeView {
  const struct R2CompoundShapeDesc *data;
  size_t count;
} R2CompoundShapeView;

typedef struct R2ShapeDesc {
  uint32_t kind;
  struct R2Vector a;
  struct R2Vector b;
  struct R2Vector c;
  R2Real radius;
  R2Real halfHeight;
  R2Real borderRadius;
  struct R2VectorView vertices;
  struct R2TriangleView triangles;
  struct R2EdgeView edges;
  uint32_t flags;
  struct R2RealView heights;
  size_t rows;
  size_t columns;
  struct R2Vector scale;
  const R2SharedShape *sharedShape;
  struct R2CompoundShapeView children;
} R2ShapeDesc;

typedef struct R2CompoundShapeDesc {
  struct R2Pose pose;
  struct R2ShapeDesc shape;
} R2CompoundShapeDesc;
 
 
#if defined(RAPIER_DIM2)
typedef R2Real R2AngVector;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R2Vector R2AngVector;
#endif

typedef struct R2MassProperties {
  struct R2Vector local_com;
  R2Real mass;
  R2AngVector principal_inertia;
#if defined(RAPIER_DIM3)
  struct R2Rotation principal_inertia_local_frame;
#endif
} R2MassProperties;

typedef struct R2InteractionGroups {
  uint32_t memberships;
  uint32_t filter;
  uint32_t test_mode;
} R2InteractionGroups;

typedef struct R2ColliderDesc {
  struct R2ShapeDesc shape;
  struct R2Pose position;
  uint32_t massMode;
  R2Real density;
  R2Real mass;
  struct R2MassProperties massProperties;
  R2Real friction;
  R2Real restitution;
  uint32_t frictionCombineRule;
  uint32_t restitutionCombineRule;
  R2Bool isSensor;
  R2Bool enabled;
  struct R2InteractionGroups collisionGroups;
  struct R2InteractionGroups solverGroups;
  uint16_t activeCollisionTypes;
  uint32_t activeHooks;
  uint32_t activeEvents;
  R2Real contactForceEventThreshold;
  R2Real contactSkin;
  struct R2UserData userData;
} R2ColliderDesc;

typedef struct R2SoftBodyDesc {
  uint32_t kind;
  struct R2Vector a;
  struct R2Vector b;
  struct R2Vector du;
  struct R2Vector dv;
#if defined(RAPIER_DIM3)
  struct R2SpringCoefficients warpSoftness;
#endif
#if defined(RAPIER_DIM3)
  struct R2SpringCoefficients weftSoftness;
#endif
#if defined(RAPIER_DIM3)
  struct R2SpringCoefficients shearSoftness;
#endif
  size_t nx;
  size_t ny;
  size_t nz;
  R2Real radius;
  R2Real radiusEnd;
  struct R2Vector translation;
  struct R2OptionalReal totalMass;
  struct R2VolumeMeshParameters meshing;
  struct R2VectorView positions;
  struct R2RealView masses;
  struct R2IndexView pinned;
  struct R2EdgeView edges;
  struct R2EdgeView bendEdges;
  struct R2IndexView tensionOnlyEdges;
  struct R2SoftEdgeSoftnessView edgeSoftness;
  struct R2SoftEdgeTearView edgeTearResistance;
  R2CellView cells;
  R2SurfaceElementView surface;
#if defined(RAPIER_DIM3)
  struct R2DihedralView dihedrals;
#endif
#if defined(RAPIER_DIM3)
  struct R2EdgeView wire;
#endif
  struct R2VectorView skinVertices;
  R2SurfaceElementView skinIndices;
  struct R2SoftBodyDescView appended;
  struct R2EdgeView addedEdges;
  struct R2SoftBodyMaterial material;
  uint32_t cellModel;
  uint32_t solver;
  R2Real particleMass;
  struct R2OptionalReal particleRadius;
  R2Bool volumePreservation;
  R2Real volumeFactor;
  struct R2OptionalBool shapeMatching;
  struct R2OptionalBool oriented;
  R2Bool selfContacts;
  R2Bool skinCollision;
  R2Bool collisionEnabled;
  struct R2ColliderDesc collider;
  R2Real linearDamping;
  R2Real gravityScale;
  size_t additionalSolverIterations;
  size_t additionalPgsIterations;
  R2Bool canSleep;
  int8_t dominanceGroup;
  struct R2UserData userData;
} R2SoftBodyDesc;

typedef struct R2SoftBodyHandle {
  struct R2World *world;
  uint32_t index;
  uint32_t generation;
} R2SoftBodyHandle;

typedef struct R2SoftMeshBindingDesc {
  uint32_t kind;
  struct R2IndexView particles;
  R2Real epsilon;
  R2Bool selfContacts;
} R2SoftMeshBindingDesc;

typedef struct R2ColliderHandle {
  struct R2World *world;
  uint32_t index;
  uint32_t generation;
} R2ColliderHandle;

typedef struct R2QueryFilter {
  uint32_t flags;
  R2Bool use_groups;
  struct R2InteractionGroups groups;
  struct R2ColliderHandle exclude_collider;
  struct R2RigidBodyHandle exclude_rigid_body;
} R2QueryFilter;

typedef R2Bool (RAPIER_CALL *R2QueryPredicate)(void *user_data,
                                     const struct R2ReadContext *read,
                                     struct R2ColliderHandle handle);

typedef struct R2QueryOptions {
  struct R2QueryFilter filter;
  R2QueryPredicate predicate;
  void *userData;
} R2QueryOptions;

typedef struct R2RayHit {
  struct R2ColliderHandle collider;
  R2Real time_of_impact;
  struct R2Vector normal;
  uint32_t feature_type;
  uint32_t feature_id;
} R2RayHit;

typedef struct R2PointProjection {
  struct R2ColliderHandle collider;
  struct R2Vector point;
  R2Bool is_inside;
} R2PointProjection;

typedef struct R2ShapeCastHit {
  struct R2ColliderHandle collider;
  R2Real time_of_impact;
  struct R2Vector witness1;
  struct R2Vector witness2;
  struct R2Vector normal1;
  struct R2Vector normal2;
  uint32_t status;
} R2ShapeCastHit;

typedef struct R2ShapeCastOptions {
  R2Real max_time_of_impact;
  R2Real target_distance;
  R2Bool stop_at_penetration;
  R2Bool compute_impact_geometry_on_penetration;
} R2ShapeCastOptions;

typedef struct R2Aabb {
  struct R2Vector mins;
  struct R2Vector maxs;
} R2Aabb;

typedef struct R2RayToi {
  struct R2ColliderHandle collider;
  R2Real toi;
  R2Bool found;
} R2RayToi;

typedef struct R2OptionalRayHit {
  struct R2RayHit hit;
  R2Bool found;
} R2OptionalRayHit;

typedef struct R2RigidBodyDesc {
  struct R2Pose position;
  struct R2Vector linvel;
  R2AngVector angvel;
  uint32_t bodyType;
  R2Real gravityScale;
  R2Real linearDamping;
  R2Real angularDamping;
  R2Real additionalMass;
  R2Bool useAdditionalMassProperties;
  struct R2MassProperties additionalMassProperties;
  uint8_t lockedAxes;
  R2Bool canSleep;
  R2Bool sleeping;
  R2Bool ccdEnabled;
  R2Real softCcdPrediction;
  R2Bool allowFastRotation;
  R2Bool enabled;
  int8_t dominanceGroup;
  size_t additionalSolverIterations;
  size_t additionalPgsIterations;
  R2Bool gyroscopicForcesEnabled;
  struct R2UserData userData;
} R2RigidBodyDesc;

typedef struct R2PodLayout {
  size_t rigidBodyDesc;
  size_t colliderDesc;
  size_t shapeDesc;
  size_t jointDesc;
  size_t softBodyMaterial;
  size_t integrationParameters;
  size_t softBodyDesc;
  size_t softMeshBindingDesc;
  size_t queryOptions;
  size_t urdfLoaderOptions;
  size_t mjcfLoaderOptions;
} R2PodLayout;

typedef struct R2CharacterLength {
  R2Real value;
  R2Bool relative;
} R2CharacterLength;

typedef struct R2CharacterAutostep {
  R2Bool enabled;
  struct R2CharacterLength max_height;
  struct R2CharacterLength min_width;
  R2Bool include_dynamic_bodies;
} R2CharacterAutostep;

typedef struct R2CharacterMovement {
  struct R2Vector translation;
  R2Bool grounded;
  R2Bool is_sliding_down_slope;
} R2CharacterMovement;

typedef struct R2CharacterCollision {
  struct R2ColliderHandle collider;
  struct R2Pose character_pos;
  struct R2Vector translation_applied;
  struct R2Vector translation_remaining;
  struct R2ShapeCastHit hit;
} R2CharacterCollision;

typedef struct R2PidGains {
  struct R2Vector lin_kp;
  struct R2Vector lin_ki;
  struct R2Vector lin_kd;
  R2AngVector ang_kp;
  R2AngVector ang_ki;
  R2AngVector ang_kd;
} R2PidGains;

typedef struct R2PdController {
  struct R2Vector lin_kp;
  struct R2Vector lin_kd;
  R2AngVector ang_kp;
  R2AngVector ang_kd;
  uint32_t axes;
} R2PdController;

typedef struct R2VelocityCorrection {
  struct R2Vector linear;
  R2AngVector angularVelocity;
} R2VelocityCorrection;

typedef struct R2CharacterControllerSettings {
  R2Bool slide;
  R2Real max_slope_climb_angle;
  R2Real min_slope_slide_angle;
  R2Bool snap_to_ground;
  struct R2CharacterLength snap_distance;
} R2CharacterControllerSettings;
 
#if defined(RAPIER_DIM3)
typedef struct R2WheelTuning {
  R2Real suspension_stiffness;
  R2Real suspension_compression;
  R2Real suspension_damping;
  R2Real max_suspension_travel;
  R2Real friction_slip;
  R2Real max_suspension_force;
  R2Real side_friction_stiffness;
} R2WheelTuning;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R2WheelState {
  struct R2Vector center;
  struct R2Vector suspension;
  struct R2Vector axle;
  R2Real rotation;
  R2Real suspension_force;
  R2Real suspension_length;
  R2Bool is_in_contact;
  struct R2ColliderHandle ground_object;
  struct R2Vector contact_point;
  struct R2Vector contact_normal;
} R2WheelState;
#endif

typedef void (RAPIER_CALL *R2ErrorCallback)(R2Status, const char*, void*);

typedef struct R2ErrorHandler {
  R2ErrorCallback callback;
  void *user_data;
} R2ErrorHandler;

typedef struct R2JointBodies {
  struct R2RigidBodyHandle body1;
  struct R2RigidBodyHandle body2;
} R2JointBodies;

typedef struct R2InverseKinematicsOptions {
  R2Real damping;
  size_t max_iters;
  uint8_t constrained_axes;
  R2Real epsilon_linear;
  R2Real epsilon_angular;
} R2InverseKinematicsOptions;

typedef R2Bool (RAPIER_CALL *R2IkJointCanMove)(void*, struct R2RigidBodyHandle);

typedef struct R2CollisionEvent {
  struct R2ColliderHandle collider1;
  struct R2ColliderHandle collider2;
  R2Bool started;
  uint32_t flags;
} R2CollisionEvent;

typedef struct R2ContactForceEvent {
  struct R2ColliderHandle collider1;
  struct R2ColliderHandle collider2;
  struct R2Vector total_force;
  R2Real total_force_magnitude;
  struct R2Vector max_force_direction;
  R2Real max_force_magnitude;
  R2Bool started;
} R2ContactForceEvent;

typedef int32_t (RAPIER_CALL *R2PairFilter)(void *user_data,
                                 const struct R2ReadContext *read,
                                 struct R2ColliderHandle collider1,
                                 struct R2ColliderHandle collider2,
                                 struct R2RigidBodyHandle body1,
                                 struct R2RigidBodyHandle body2);

typedef struct R2ContactModification {
  struct R2Vector normal;
  R2Real friction;
  R2Real restitution;
  uint32_t user_data;
  R2Bool enabled;
} R2ContactModification;

typedef void (RAPIER_CALL *R2ModifyContacts)(void *user_data,
                                  const struct R2ReadContext *read,
                                  struct R2ColliderHandle collider1,
                                  struct R2ColliderHandle collider2,
                                  struct R2ContactModification *contact);

typedef void (RAPIER_CALL *R2ModifyContactContext)(void *user_data,
                                        const struct R2ReadContext *read,
                                        struct R2ColliderHandle collider1,
                                        struct R2ColliderHandle collider2,
                                        struct R2ContactModificationContext *context);

typedef struct R2PhysicsHooks {
  void *user_data;
  R2PairFilter filter_contact_pair;
  R2PairFilter filter_intersection_pair;
  R2ModifyContacts modify_solver_contacts;
  R2ModifyContactContext modify_solver_contacts_context;
} R2PhysicsHooks;

typedef struct R2ByteView {
  const uint8_t *data;
  size_t count;
} R2ByteView;

typedef struct R2DebugLine {
  struct R2Vector a;
  struct R2Vector b;
  float color[4];
} R2DebugLine;

typedef struct R2ParticleDestination {
  struct R2SoftBodyHandle body;
  uint32_t index;
} R2ParticleDestination;

typedef struct R2SoftClusterSplit {
  uint32_t source_cluster;
  struct R2SoftBodyHandle soft_body;
  uint32_t cluster;
  struct R2RigidBodyHandle proxy;
  R2Bool keeps_proxy;
} R2SoftClusterSplit;

typedef struct R2SoftJointMove {
  struct R2ImpulseJointHandle joint;
  struct R2RigidBodyHandle from;
  struct R2RigidBodyHandle to;
} R2SoftJointMove;

typedef struct R2OptionalParticleDestination {
  struct R2SoftBodyHandle body;
  uint32_t index;
  R2Bool found;
} R2OptionalParticleDestination;

typedef struct R2BuildInfo {
  uint32_t abi_version;
  uint32_t dimension;
  uint32_t real_size;
  uint32_t pointer_size;
} R2BuildInfo;

typedef struct R2BuildFeatures {
  R2Bool profiling;
  uint32_t simd_lanes;
  R2Bool parallel;
  R2Bool enhanced_determinism;
} R2BuildFeatures;

typedef struct R2ContactPair {
  struct R2ColliderHandle collider1;
  struct R2ColliderHandle collider2;
  R2Bool has_any_active_contact;
  struct R2Vector total_impulse;
  R2Real total_impulse_magnitude;
  R2Real max_impulse;
  struct R2Vector max_impulse_direction;
} R2ContactPair;

typedef struct R2IntersectionPair {
  struct R2ColliderHandle collider1;
  struct R2ColliderHandle collider2;
  R2Bool intersecting;
} R2IntersectionPair;

typedef struct R2ContactPoint {
  size_t manifold_index;
  struct R2Vector local_p1;
  struct R2Vector local_p2;
  struct R2Vector normal;
  R2Real distance;
  R2Real impulse;
#if defined(RAPIER_DIM2)
  R2Real tangent_impulse[1];
#endif
#if defined(RAPIER_DIM3)
  R2Real tangent_impulse[2];
#endif
} R2ContactPoint;
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2UrdfLoaderOptions {
  R2Bool createCollidersFromCollisionShapes;
  R2Bool createCollidersFromVisualShapes;
  R2Bool applyImportedMassProps;
  R2Bool enableJointCollisions;
  R2Bool makeRootsFixed;
  R2Bool squeezeEmptyFixedLinks;
  struct R2Pose shift;
  R2Real scale;
  struct R2ColliderDesc colliderBlueprint;
  struct R2RigidBodyDesc rigidBodyBlueprint;
} R2UrdfLoaderOptions;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfLoaderOptions {
  R2Bool createCollidersFromCollisionShapes;
  R2Bool createCollidersFromVisualShapes;
  R2Bool applyImportedMassProps;
  R2Bool enableJointCollisions;
  R2Bool makeRootsFixed;
  R2Bool skipPlaneGeoms;
  R2Bool disableJointMotors;
  struct R2Pose shift;
  R2Real scale;
  struct R2ColliderDesc colliderBlueprint;
  struct R2RigidBodyDesc rigidBodyBlueprint;
} R2MjcfLoaderOptions;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfVisualMesh R2MjcfVisualMesh;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2RenderMaterial {
  float metallic;
  float roughness;
  float reflectance;
  float emissive[3];
} R2RenderMaterial;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R2MjcfVisualMeshInfo {
  struct R2Pose local_pose;
  float rgba[4];
  struct R2RenderMaterial material;
  R2Bool has_color;
  R2Bool has_material;
  R2Bool is_trimesh;
} R2MjcfVisualMeshInfo;
#endif

typedef struct R2RigidBodyState {
  struct R2Pose position;
  struct R2Vector linvel;
  R2AngVector angvel;
  R2Bool sleeping;
  R2Bool enabled;
  struct R2UserData userData;
} R2RigidBodyState;

typedef struct R2SoftMeshId {
  uint32_t cluster;
  uint32_t mesh;
} R2SoftMeshId;

typedef struct R2SoftMeshInfo {
  struct R2SoftMeshId id;
  struct R2ColliderHandle collider;
  size_t arity;
  R2Bool is_skinned;
  R2Bool collision_enabled;
} R2SoftMeshInfo;
 
#if defined(RAPIER_F32)
typedef int32_t R2VoxelCoord;
#endif
 
#if defined(RAPIER_F64)
typedef int64_t R2VoxelCoord;
#endif

typedef struct R2VoxelKey {
  R2VoxelCoord x;
  R2VoxelCoord y;
#if defined(RAPIER_DIM3)
  R2VoxelCoord z;
#endif
} R2VoxelKey;

typedef struct R2VoxelQuery {
  struct R2VoxelKey key;
  struct R2Vector center;
  struct R2Vector size;
  R2Bool found;
} R2VoxelQuery;

typedef struct R2JointImpulses {
  struct R2Vector linear;
  R2AngVector angular;
  R2Real limits[R2_JOINT_DOF_COUNT];
  R2Real motors[R2_JOINT_DOF_COUNT];
} R2JointImpulses;

typedef struct R2OptionalShapeCastHit {
  struct R2ShapeCastHit hit;
  R2Bool found;
} R2OptionalShapeCastHit;

typedef struct R2OptionalPointProjection {
  struct R2PointProjection projection;
  R2Bool found;
} R2OptionalPointProjection;

typedef struct R2NonlinearRigidMotion {
  struct R2Pose start;
  struct R2Vector local_center;
  struct R2Vector linvel;
  R2AngVector angvel;
} R2NonlinearRigidMotion;

typedef struct R2OptionalContactPair {
  struct R2ContactPair pair;
  R2Bool found;
} R2OptionalContactPair;

typedef struct R2OptionalIntersectionPair {
  struct R2IntersectionPair pair;
  R2Bool found;
} R2OptionalIntersectionPair;

typedef struct R2ContactManifold {
  struct R2Vector local_n1;
  struct R2Vector local_n2;
  struct R2Vector normal;
  uint32_t subshape1;
  uint32_t subshape2;
  size_t num_points;
  size_t num_solver_contacts;
  uint32_t user_data;
} R2ContactManifold;

typedef struct R2SolverContact {
  struct R2Vector point1;
  struct R2Vector point2;
  R2Real distance;
  struct R2Vector tangent_velocity;
} R2SolverContact;

typedef void (RAPIER_CALL *R2CollisionEventCallback)(void *user_data,
                                          const struct R2ReadContext *read,
                                          const struct R2CollisionEvent *event,
                                          const struct R2ContactPoint *contacts,
                                          size_t contact_count);

typedef void (RAPIER_CALL *R2ContactForceEventCallback)(void *user_data,
                                             const struct R2ReadContext *read,
                                             const struct R2ContactForceEvent *event);

typedef struct R2EventCallbacks {
  void *user_data;
  R2CollisionEventCallback collision_event;
  R2ContactForceEventCallback contact_force_event;
} R2EventCallbacks;

typedef struct R2DebugRenderStyle {
  uint32_t subdivisions;
  uint32_t border_subdivisions;
  float collider_dynamic_color[4];
  float collider_fixed_color[4];
  float collider_kinematic_color[4];
  float collider_parentless_color[4];
  float impulse_joint_anchor_color[4];
  float impulse_joint_separation_color[4];
  float multibody_joint_anchor_color[4];
  float multibody_joint_separation_color[4];
  float sleep_color_multiplier[4];
  float sleep_eligible_color_multiplier[4];
  float disabled_color_multiplier[4];
  R2Real rigid_body_axes_length;
  float contact_depth_color[4];
  float contact_normal_color[4];
  R2Real contact_normal_length;
  float soft_body_element_color[4];
  float soft_body_slack_color[4];
  float soft_body_loaded_color[4];
  float soft_body_frame_color[4];
  float collider_aabb_color[4];
  float vertex_pseudo_normal_color[4];
  float edge_pseudo_normal_color[4];
  R2Real pseudo_normal_length;
  float volume_contact_normal_color[4];
  float volume_gradient_color[4];
} R2DebugRenderStyle;

#define R2_OK 0

#define R2_NULL_POINTER 1

#define R2_INVALID_ARGUMENT 2

#define R2_INVALID_HANDLE 3

#define R2_BUFFER_TOO_SMALL 4

#define R2_UNSUPPORTED 5

#define R2_PANIC 6

#define R2_NOT_FOUND 7

#define R2_WORLD_BUSY 8
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

RAPIER_API struct R2SoftBodyMaterial RAPIER_CALL r2DefaultSoftBodyMaterial(void);

RAPIER_API struct R2SoftRecoverySettings RAPIER_CALL r2DefaultSoftRecoverySettings(void);
 
#if defined(RAPIER_FEM)
RAPIER_API struct R2SoftFemParameters RAPIER_CALL r2DefaultSoftFemParameters(void);
#endif

RAPIER_API struct R2SoftBodiesSettings RAPIER_CALL r2DefaultSoftBodiesSettings(void);

RAPIER_API struct R2IntegrationParameters RAPIER_CALL r2DefaultIntegrationParameters(void);

RAPIER_API struct R2IntegrationParameters RAPIER_CALL r2IntegrationParameters(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetIntegrationParameters(struct R2World *world,
                                         const struct R2IntegrationParameters *data);

RAPIER_API struct R2JointDesc RAPIER_CALL r2DefaultJointDesc(void);

RAPIER_API struct R2JointDesc RAPIER_CALL r2FixedJointDesc(void);
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R2JointDesc RAPIER_CALL r2RevoluteJointDesc(void);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2JointDesc RAPIER_CALL r2RevoluteJointDesc(struct R2Vector axis_vector);
#endif

RAPIER_API struct R2JointDesc RAPIER_CALL r2PrismaticJointDesc(struct R2Vector axis_vector);

RAPIER_API struct R2JointDesc RAPIER_CALL r2RopeJointDesc(R2Real length);

RAPIER_API
struct R2JointDesc RAPIER_CALL r2SpringJointDesc(R2Real length,
                                          R2Real stiffness,
                                          R2Real damping);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2JointDesc RAPIER_CALL r2SphericalJointDesc(void);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R2JointDesc RAPIER_CALL r2PinSlotJointDesc(struct R2Vector axis_vector);
#endif

RAPIER_API
struct R2ImpulseJointHandle RAPIER_CALL r2InsertImpulseJoint(struct R2RigidBodyHandle body1,
                                                      struct R2RigidBodyHandle body2,
                                                      const struct R2JointDesc *joint);

RAPIER_API
struct R2MultibodyJointHandle RAPIER_CALL r2InsertMultibodyJoint(struct R2RigidBodyHandle body1,
                                                          struct R2RigidBodyHandle body2,
                                                          const struct R2JointDesc *joint);

RAPIER_API struct R2SoftBodyDesc RAPIER_CALL r2DefaultSoftBodyDesc(void);

RAPIER_API
struct R2SoftBodyHandle RAPIER_CALL r2InsertSoftBody(struct R2World *world,
                                              const struct R2SoftBodyDesc *desc);

RAPIER_API struct R2SoftMeshBindingDesc RAPIER_CALL r2DefaultSoftMeshBindingDesc(void);

RAPIER_API
struct R2ColliderHandle RAPIER_CALL r2InsertDeformableCollider(const struct R2ColliderDesc *collider,
                                                        const struct R2SoftMeshBindingDesc *binding,
                                                        struct R2RigidBodyHandle parent);

RAPIER_API struct R2QueryOptions RAPIER_CALL r2DefaultQueryOptions(void);

RAPIER_API
struct R2RayHit RAPIER_CALL r2CastRay(const struct R2World *world,
                              const struct R2QueryOptions *query_options,
                              struct R2Vector origin,
                              struct R2Vector direction,
                              R2Real max_toi,
                              R2Bool solid);

RAPIER_API
struct R2PointProjection RAPIER_CALL r2ProjectPoint(const struct R2World *world,
                                            const struct R2QueryOptions *query_options,
                                            struct R2Vector point,
                                            R2Real max_distance,
                                            R2Bool solid);

RAPIER_API
struct R2ShapeCastHit RAPIER_CALL r2CastShape(const struct R2World *world,
                                      const struct R2QueryOptions *query_options,
                                      struct R2Pose pose,
                                      struct R2Vector velocity,
                                      const R2SharedShape *shape,
                                      struct R2ShapeCastOptions options);

RAPIER_API
size_t RAPIER_CALL r2IntersectPoint(const struct R2World *world,
                           const struct R2QueryOptions *query_options,
                           struct R2Vector point,
                           struct R2ColliderHandle *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2IntersectShape(const struct R2World *world,
                           const struct R2QueryOptions *query_options,
                           struct R2Pose pose,
                           const R2SharedShape *shape,
                           struct R2ColliderHandle *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2IntersectAabbConservative(const struct R2World *world,
                                       const struct R2QueryOptions *query_options,
                                       struct R2Aabb aabb,
                                       struct R2ColliderHandle *buffer,
                                       size_t capacity);

RAPIER_API
struct R2RayToi RAPIER_CALL r2CastRayToi(const struct R2World *world,
                                  const struct R2QueryOptions *query_options,
                                  struct R2Vector origin,
                                  struct R2Vector direction,
                                  R2Real max_toi,
                                  R2Bool solid);

RAPIER_API
struct R2OptionalRayHit RAPIER_CALL r2TryCastRay(const struct R2World *world,
                                          const struct R2QueryOptions *query_options,
                                          struct R2Vector origin,
                                          struct R2Vector direction,
                                          R2Real max_toi,
                                          R2Bool solid);

RAPIER_API struct R2RigidBodyDesc RAPIER_CALL r2DynamicRigidBodyDesc(void);

RAPIER_API struct R2RigidBodyDesc RAPIER_CALL r2FixedRigidBodyDesc(void);

RAPIER_API struct R2RigidBodyDesc RAPIER_CALL r2KinematicPositionBasedRigidBodyDesc(void);

RAPIER_API struct R2RigidBodyDesc RAPIER_CALL r2KinematicVelocityBasedRigidBodyDesc(void);

RAPIER_API struct R2ShapeDesc RAPIER_CALL r2DefaultShapeDesc(void);

RAPIER_API R2SharedShape *RAPIER_CALL r2ShapeDesc_Build(const struct R2ShapeDesc *desc);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2DefaultColliderDesc(void);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2BallColliderDesc(R2Real radius);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2CuboidColliderDesc(struct R2Vector half_extents);

RAPIER_API
struct R2RigidBodyHandle RAPIER_CALL r2InsertRigidBody(struct R2World *world,
                                                const struct R2RigidBodyDesc *desc);

RAPIER_API
struct R2ColliderHandle RAPIER_CALL r2InsertCollider(struct R2RigidBodyHandle parent,
                                             const struct R2ColliderDesc *desc);

RAPIER_API
struct R2ColliderHandle RAPIER_CALL r2InsertColliderWithoutParent(struct R2World *world,
                                                            const struct R2ColliderDesc *desc);

RAPIER_API struct R2PodLayout RAPIER_CALL r2PodLayout(void);

RAPIER_API struct R2KinematicCharacterController *RAPIER_CALL r2NewKinematicCharacterController(void);

RAPIER_API
R2Status RAPIER_CALL r2FreeKinematicCharacterController(struct R2KinematicCharacterController *controller);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetUp(struct R2KinematicCharacterController *controller,
                                                    struct R2Vector up);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetOffset(struct R2KinematicCharacterController *controller,
                                                        struct R2CharacterLength offset);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetSlide(struct R2KinematicCharacterController *controller,
                                                       R2Bool enabled);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetSlopes(struct R2KinematicCharacterController *controller,
                                                        R2Real max_climb_angle,
                                                        R2Real min_slide_angle);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetAutostep(struct R2KinematicCharacterController *controller,
                                                          R2Bool enabled,
                                                          struct R2CharacterLength max_height,
                                                          struct R2CharacterLength min_width,
                                                          R2Bool include_dynamic_bodies);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetSnapToGround(struct R2KinematicCharacterController *controller,
                                                                R2Bool enabled,
                                                                struct R2CharacterLength distance);

RAPIER_API
struct R2Vector RAPIER_CALL r2KinematicCharacterController_Up(const struct R2KinematicCharacterController *controller);

RAPIER_API
struct R2CharacterLength RAPIER_CALL r2KinematicCharacterController_Offset(const struct R2KinematicCharacterController *controller);

RAPIER_API
struct R2CharacterAutostep RAPIER_CALL r2KinematicCharacterController_Autostep(const struct R2KinematicCharacterController *controller);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SetNormalNudgeFactor(struct R2KinematicCharacterController *controller,
                                                                     R2Real value);

RAPIER_API
R2Real RAPIER_CALL r2KinematicCharacterController_NormalNudgeFactor(const struct R2KinematicCharacterController *controller);

RAPIER_API
struct R2CharacterMovement RAPIER_CALL r2KinematicCharacterController_MoveShape(const struct R2World *world,
                                                                          const struct R2QueryOptions *options,
                                                                          struct R2KinematicCharacterController *controller,
                                                                          R2Real dt,
                                                                          const R2SharedShape *shape,
                                                                          struct R2Pose pose,
                                                                          struct R2Vector desired_translation);

RAPIER_API
size_t RAPIER_CALL r2KinematicCharacterController_Collisions(const struct R2KinematicCharacterController *controller,
                                                     struct R2CharacterCollision *buffer,
                                                     size_t capacity);

RAPIER_API
R2Status RAPIER_CALL r2KinematicCharacterController_SolveCharacterCollisionImpulses(const struct R2KinematicCharacterController *controller,
                                                                                const R2SharedShape *shape,
                                                                                R2Real dt,
                                                                                R2Real mass,
                                                                                const struct R2QueryOptions *options);

RAPIER_API struct R2PidController *RAPIER_CALL r2NewPidController(void);

RAPIER_API R2Status RAPIER_CALL r2FreePidController(struct R2PidController *controller);

RAPIER_API struct R2PidGains RAPIER_CALL r2PidController_Gains(const struct R2PidController *controller);

RAPIER_API
R2Status RAPIER_CALL r2PidController_SetGains(struct R2PidController *controller,
                                       struct R2PidGains gains);

RAPIER_API
R2Status RAPIER_CALL r2PidController_SetAxes(struct R2PidController *controller,
                                      uint32_t axes);

RAPIER_API uint32_t RAPIER_CALL r2PidController_Axes(const struct R2PidController *controller);

RAPIER_API R2Status RAPIER_CALL r2PidController_ResetIntegrals(struct R2PidController *controller);

RAPIER_API struct R2PdController RAPIER_CALL r2DefaultPdController(void);

RAPIER_API
struct R2VelocityCorrection RAPIER_CALL r2PdController_RigidBodyCorrection(const struct R2PdController *controller,
                                                                     struct R2RigidBodyHandle body,
                                                                     struct R2Pose target_pose,
                                                                     struct R2Vector target_linvel,
                                                                     R2AngVector target_angvel);

RAPIER_API
struct R2VelocityCorrection RAPIER_CALL r2PidController_RigidBodyCorrection(struct R2PidController *controller,
                                                                      R2Real dt,
                                                                      struct R2RigidBodyHandle body,
                                                                      struct R2Pose target_pose,
                                                                      struct R2Vector target_linvel,
                                                                      R2AngVector target_angvel);

RAPIER_API
struct R2CharacterControllerSettings RAPIER_CALL r2KinematicCharacterController_Settings(const struct R2KinematicCharacterController *controller);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2WheelTuning RAPIER_CALL r2DefaultWheelTuning(void);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2DynamicRayCastVehicleController *RAPIER_CALL r2NewDynamicRayCastVehicleController(struct R2RigidBodyHandle chassis);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2FreeDynamicRayCastVehicleController(struct R2DynamicRayCastVehicleController *controller);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r2DynamicRayCastVehicleController_AddWheel(struct R2DynamicRayCastVehicleController *controller,
                                                         struct R2Vector connection,
                                                         struct R2Vector direction,
                                                         struct R2Vector axle,
                                                         R2Real rest_length,
                                                         R2Real radius,
                                                         const struct R2WheelTuning *tuning);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2DynamicRayCastVehicleController_SetAxes(struct R2DynamicRayCastVehicleController *controller,
                                                           size_t up,
                                                           size_t forward);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2DynamicRayCastVehicleController_SetWheelControls(struct R2DynamicRayCastVehicleController *controller,
                                                                     size_t index,
                                                                     R2Real steering,
                                                                     R2Real engine_force,
                                                                     R2Real brake);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2DynamicRayCastVehicleController_UpdateVehicle(struct R2DynamicRayCastVehicleController *controller,
                                                                 R2Real dt,
                                                                 const struct R2QueryOptions *options);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Real RAPIER_CALL r2DynamicRayCastVehicleController_CurrentVehicleSpeed(const struct R2DynamicRayCastVehicleController *controller);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r2DynamicRayCastVehicleController_Wheels(const struct R2DynamicRayCastVehicleController *controller,
                                                      struct R2WheelState *buffer,
                                                      size_t capacity);
#endif

RAPIER_API
R2Status RAPIER_CALL r2RigidBodyPropagateModifiedBodyPositionsToColliders(struct R2World *world);

RAPIER_API
size_t RAPIER_CALL r2ActiveRigidBodies(const struct R2World *world,
                               struct R2RigidBodyHandle *buffer,
                               size_t capacity);

RAPIER_API R2Status RAPIER_CALL r2RigidBody_WakeUp(struct R2RigidBodyHandle handle, R2Bool strong);

RAPIER_API struct R2ErrorHandler RAPIER_CALL r2SetErrorHandler(struct R2ErrorHandler handler);

RAPIER_API R2Status RAPIER_CALL r2LastStatus(void);

RAPIER_API const char *RAPIER_CALL r2LastError(void);

RAPIER_API R2SharedShape *RAPIER_CALL r2BallSharedShape(R2Real radius);

RAPIER_API R2SharedShape *RAPIER_CALL r2CuboidSharedShape(struct R2Vector half_extents);

RAPIER_API
R2SharedShape *RAPIER_CALL r2RoundCuboidSharedShape(struct R2Vector half_extents,
                                              R2Real border_radius);

RAPIER_API
R2SharedShape *RAPIER_CALL r2CapsuleSharedShape(struct R2Vector a,
                                         struct R2Vector b,
                                         R2Real radius);

RAPIER_API R2SharedShape *RAPIER_CALL r2SegmentSharedShape(struct R2Vector a, struct R2Vector b);

RAPIER_API
R2SharedShape *RAPIER_CALL r2TriangleSharedShape(struct R2Vector a,
                                          struct R2Vector b,
                                          struct R2Vector c);

RAPIER_API R2SharedShape *RAPIER_CALL r2HalfspaceSharedShape(struct R2Vector normal);
 
#if defined(RAPIER_DIM3)
RAPIER_API R2SharedShape *RAPIER_CALL r2CylinderSharedShape(R2Real half_height, R2Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R2SharedShape *RAPIER_CALL r2ConeSharedShape(R2Real half_height, R2Real radius);
#endif

RAPIER_API R2SharedShape *RAPIER_CALL r2CompoundSharedShape(struct R2CompoundShapeView children);

RAPIER_API R2Status RAPIER_CALL r2RemoveCollider(struct R2ColliderHandle handle, R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2RemoveImpulseJoint(struct R2ImpulseJointHandle handle, R2Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r2ImpulseJointHandles(const struct R2World *world,
                                 struct R2ImpulseJointHandle *buffer,
                                 size_t capacity);

RAPIER_API
R2Status RAPIER_CALL r2RemoveMultibodyJoint(struct R2MultibodyJointHandle handle,
                                     R2Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r2MultibodyJointHandles(const struct R2World *world,
                                   struct R2MultibodyJointHandle *buffer,
                                   size_t capacity);

RAPIER_API struct R2JointBodies RAPIER_CALL r2ImpulseJoint_Bodies(struct R2ImpulseJointHandle handle);

RAPIER_API struct R2InverseKinematicsOptions RAPIER_CALL r2DefaultInverseKinematicsOptions(void);

RAPIER_API size_t RAPIER_CALL r2MultibodyJoint_Ndofs(struct R2MultibodyJointHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2MultibodyJoint_InverseKinematics(struct R2MultibodyJointHandle handle,
                                                 const struct R2InverseKinematicsOptions *options,
                                                 struct R2Pose target,
                                                 R2IkJointCanMove can_move,
                                                 void *user_data,
                                                 R2Real *displacements,
                                                 size_t count);

RAPIER_API
R2Status RAPIER_CALL r2MultibodyJoint_ApplyDisplacements(struct R2MultibodyJointHandle handle,
                                                  const R2Real *displacements,
                                                  size_t count);

RAPIER_API R2Status RAPIER_CALL r2FreeSharedShape(R2SharedShape *object);

RAPIER_API R2SharedShape *RAPIER_CALL r2SharedShape_Clone(const R2SharedShape *object);

RAPIER_API size_t RAPIER_CALL r2RigidBodyCount(const struct R2World *world);

RAPIER_API
size_t RAPIER_CALL r2RigidBodyHandles(const struct R2World *world,
                              struct R2RigidBodyHandle *buffer,
                              size_t capacity);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_Contains(struct R2RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r2ColliderCount(const struct R2World *world);

RAPIER_API
size_t RAPIER_CALL r2ColliderHandles(const struct R2World *world,
                            struct R2ColliderHandle *buffer,
                            size_t capacity);

RAPIER_API R2Bool RAPIER_CALL r2Collider_Contains(struct R2ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r2SoftBodyCount(const struct R2World *world);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyHandles(const struct R2World *world,
                             struct R2SoftBodyHandle *buffer,
                             size_t capacity);

RAPIER_API R2Bool RAPIER_CALL r2SoftBody_Contains(struct R2SoftBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2RemoveRigidBody(struct R2RigidBodyHandle handle,
                                R2Bool remove_attached_colliders);

RAPIER_API R2Real RAPIER_CALL r2TimeStep(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetTimeStep(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2MinCcdDt(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetMinCcdDt(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2LengthUnit(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetLengthUnit(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2WarmstartCoefficient(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetWarmstartCoefficient(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2NormalizedAllowedLinearError(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetNormalizedAllowedLinearError(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2NormalizedMaxCorrectiveVelocity(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetNormalizedMaxCorrectiveVelocity(struct R2World *world,
                                                     R2Real value);

RAPIER_API R2Real RAPIER_CALL r2NormalizedPredictionDistance(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetNormalizedPredictionDistance(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2NormalizedMaxLinearVelocity(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetNormalizedMaxLinearVelocity(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2NormalizedContactRecycleDistance(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetNormalizedContactRecycleDistance(struct R2World *world,
                                                      R2Real value);

RAPIER_API size_t RAPIER_CALL r2NumSolverIterations(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetNumSolverIterations(struct R2World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r2NumInternalPgsIterations(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetNumInternalPgsIterations(struct R2World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r2NumInternalStabilizationIterations(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetNumInternalStabilizationIterations(struct R2World *world,
                                                        size_t value);

RAPIER_API size_t RAPIER_CALL r2MaxCcdSubsteps(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetMaxCcdSubsteps(struct R2World *world, size_t value);

RAPIER_API R2Bool RAPIER_CALL r2ContactClustering(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetContactClustering(struct R2World *world, R2Bool value);

RAPIER_API R2Bool RAPIER_CALL r2ContactRecycling(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetContactRecycling(struct R2World *world, R2Bool value);

RAPIER_API R2Bool RAPIER_CALL r2FrictionInBiasPass(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetFrictionInBiasPass(struct R2World *world, R2Bool value);

RAPIER_API R2Bool RAPIER_CALL r2WarmstartJoints(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetWarmstartJoints(struct R2World *world, R2Bool value);

RAPIER_API struct R2SpringCoefficients RAPIER_CALL r2ContactSoftness(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetContactSoftness(struct R2World *world,
                                   struct R2SpringCoefficients value);

RAPIER_API struct R2SpringCoefficients RAPIER_CALL r2StaticContactSoftness(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2SetStaticContactSoftness(struct R2World *world,
                                          struct R2SpringCoefficients value);

RAPIER_API
R2Status RAPIER_CALL r2ContactModificationContext_UpdateAsOnewayPlatform(struct R2ContactModificationContext *context,
                                                                     struct R2Vector allowed_local_n1,
                                                                     R2Real allowed_angle);

RAPIER_API
R2Status RAPIER_CALL r2ContactModificationContext_SetTangentVelocity(struct R2ContactModificationContext *context,
                                                                struct R2Vector velocity);

RAPIER_API struct R2EventCollector *RAPIER_CALL r2NewEventCollector(void);

RAPIER_API R2Status RAPIER_CALL r2FreeEventCollector(struct R2EventCollector *events);

RAPIER_API R2Status RAPIER_CALL r2EventCollector_Clear(struct R2EventCollector *events);

RAPIER_API
size_t RAPIER_CALL r2EventCollector_CollisionEvents(const struct R2EventCollector *events,
                                            struct R2CollisionEvent *buffer,
                                            size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2EventCollector_ContactForceEvents(const struct R2EventCollector *events,
                                                struct R2ContactForceEvent *buffer,
                                                size_t capacity);

RAPIER_API size_t RAPIER_CALL r2EventCollector_TearEventCount(const struct R2EventCollector *events);

RAPIER_API
struct R2SoftBodyTearEvent *RAPIER_CALL r2EventCollector_TearEvent(const struct R2EventCollector *events,
                                                            size_t index);

RAPIER_API struct R2Vector RAPIER_CALL r2Gravity(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetGravity(struct R2World *world, struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2Step(struct R2World *world,
                   const struct R2PhysicsHooks *hooks,
                   const struct R2EventCollector *events);

RAPIER_API
R2Status RAPIER_CALL r2DetectCollisions(struct R2World *world,
                                const struct R2PhysicsHooks *hooks,
                                const struct R2EventCollector *events);

RAPIER_API struct R2ByteView RAPIER_CALL r2Bytes_Data(const struct R2Bytes *bytes);

RAPIER_API R2Status RAPIER_CALL r2FreeBytes(struct R2Bytes *bytes);

RAPIER_API struct R2Bytes *RAPIER_CALL r2SerializeWorld(const struct R2World *world);

RAPIER_API struct R2World *RAPIER_CALL r2DeserializeWorld(const uint8_t *data, size_t count);

RAPIER_API
size_t RAPIER_CALL r2DebugRender(const struct R2World *world,
                        uint32_t mode,
                        struct R2DebugLine *buffer,
                        size_t capacity);

RAPIER_API R2Status RAPIER_CALL r2SoftBodiesSetResweepStrain(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2SoftBodiesResweepStrain(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SoftBodiesSetContactStiffening(struct R2World *world, R2Real value);

RAPIER_API R2Real RAPIER_CALL r2SoftBodiesContactStiffening(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SoftBodiesSetMaxExtraSubsteps(struct R2World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r2SoftBodiesMaxExtraSubsteps(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetAuthoredVelocityMargin(struct R2World *world,
                                                    R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetEdgeSpeculation(struct R2World *world, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetInvertedCellDetection(struct R2World *world,
                                                   R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetSelfCrossingDetection(struct R2World *world,
                                                   R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetDetectionMotionGating(struct R2World *world,
                                                   R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetCrossBodyDetection(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetSelfStandDown(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetCrossBodyExpelGate(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetEdgeStandDown(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetCrossingRepulsion(struct R2World *world, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetCrossingRepulsionGuide(struct R2World *world,
                                                    R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetCrossingRepulsionSelfGuide(struct R2World *world,
                                                         R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetRecoveryPace(struct R2World *world, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapConstraints(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapRigid(struct R2World *world, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetOverlapSkipSelfTangled(struct R2World *world,
                                                     R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetOverlapEdgeStandDown(struct R2World *world,
                                                   R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetOverlapConstraintPace(struct R2World *world,
                                                   R2Real value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapSkinVolume(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapKeptDepth(struct R2World *world, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapSelfRegions(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapNormalPush(struct R2World *world, R2Bool value);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapMultiVolume(struct R2World *world, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetOverlapProgressMargin(struct R2World *world,
                                                   R2Real value);
 
#if defined(RAPIER_FEM)
RAPIER_API R2Status RAPIER_CALL r2FemSetLinearTolerance(struct R2World *world, R2Real value);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API R2Status RAPIER_CALL r2FemSetMaxLinearIterations(struct R2World *world, size_t value);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API R2Status RAPIER_CALL r2FemSetMaxDenseDofs(struct R2World *world, size_t value);
#endif

RAPIER_API R2Status RAPIER_CALL r2SetNumThreads(struct R2World *world, size_t num_threads);

RAPIER_API R2Status RAPIER_CALL r2ClearThreadPool(struct R2World *world);

RAPIER_API size_t RAPIER_CALL r2NumThreads(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2SetCountersEnabled(struct R2World *world, R2Bool enabled);

RAPIER_API double RAPIER_CALL r2StepTimeMs(const struct R2World *world);

RAPIER_API struct R2World *RAPIER_CALL r2DeserializeRigidState(const uint8_t *data, size_t count);

RAPIER_API struct R2QueryFilter RAPIER_CALL r2DefaultQueryFilter(void);

RAPIER_API struct R2ShapeCastOptions RAPIER_CALL r2DefaultShapeCastOptions(void);

RAPIER_API R2Status RAPIER_CALL r2RemoveSoftBody(struct R2SoftBodyHandle handle);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_WakeUp(struct R2SoftBodyHandle handle);

RAPIER_API R2Status RAPIER_CALL r2FreeSoftBodyTearEvent(struct R2SoftBodyTearEvent *event);

RAPIER_API
struct R2SoftBodyHandle RAPIER_CALL r2SoftBodyTearEvent_SoftBody(const struct R2SoftBodyTearEvent *event);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_Bodies(const struct R2SoftBodyTearEvent *event,
                                       struct R2SoftBodyHandle *buffer,
                                       size_t capacity);

RAPIER_API
struct R2ParticleDestination RAPIER_CALL r2SoftBodyTearEvent_ParticleDestination(const struct R2SoftBodyTearEvent *event,
                                                                            uint32_t particle);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_TornEdges(const struct R2SoftBodyTearEvent *event,
                                           uint32_t *buffer,
                                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_TornCells(const struct R2SoftBodyTearEvent *event,
                                           uint32_t *buffer,
                                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_RemovedEdges(const struct R2SoftBodyTearEvent *event,
                                              uint32_t *buffer,
                                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_SplitParticles(const struct R2SoftBodyTearEvent *event,
                                                uint32_t *buffer,
                                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_InsertedParticles(const struct R2SoftBodyTearEvent *event,
                                                   uint32_t *buffer,
                                                   size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_PieceParticles(const struct R2SoftBodyTearEvent *event,
                                                size_t piece_index,
                                                uint32_t *buffer,
                                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_Clusters(const struct R2SoftBodyTearEvent *event,
                                         struct R2SoftClusterSplit *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyTearEvent_MovedJoints(const struct R2SoftBodyTearEvent *event,
                                             struct R2SoftJointMove *buffer,
                                             size_t capacity);

RAPIER_API
struct R2SoftBodyTearEvent *RAPIER_CALL r2SoftBody_Tear(struct R2SoftBodyHandle handle,
                                                const uint32_t *edges,
                                                size_t edge_count,
                                                const uint32_t *cells,
                                                size_t cell_count);

RAPIER_API
uint32_t RAPIER_CALL r2SoftBody_AddCluster(struct R2SoftBodyHandle handle,
                                   const uint32_t *particles,
                                   size_t count);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_RemoveCluster(struct R2SoftBodyHandle handle,
                                       uint32_t cluster);

RAPIER_API
struct R2OptionalParticleDestination RAPIER_CALL r2SoftBodyTearEvent_TryParticleDestination(const struct R2SoftBodyTearEvent *event,
                                                                                        uint32_t particle);

RAPIER_API
struct R2SoftBodyTearEvent *RAPIER_CALL r2CutSoftBody(struct R2SoftBodyHandle handle,
                                               const struct R2Vector *blade);

RAPIER_API struct R2VolumeMeshParameters RAPIER_CALL r2NewVolumeMeshParameters(R2Real cell_size);

RAPIER_API struct R2BuildInfo RAPIER_CALL r2BuildInfo(void);

RAPIER_API const char *RAPIER_CALL r2Version(void);

RAPIER_API const char *RAPIER_CALL r2BuildProfile(void);

RAPIER_API struct R2BuildFeatures RAPIER_CALL r2BuildFeatures(void);

RAPIER_API
R2SharedShape *RAPIER_CALL r2HeightfieldSharedShape(struct R2RealView heights,
                                             size_t rows,
                                             size_t columns,
                                             struct R2Vector scale);

RAPIER_API
struct R2Aabb RAPIER_CALL r2SharedShape_ComputeAabb(const R2SharedShape *shape,
                                             struct R2Pose pose);

RAPIER_API
struct R2MassProperties RAPIER_CALL r2SharedShape_MassProperties(const R2SharedShape *shape,
                                                          R2Real density);

RAPIER_API
R2Bool RAPIER_CALL r2SharedShape_ContainsPoint(const R2SharedShape *shape,
                                        struct R2Pose pose,
                                        struct R2Vector point);

RAPIER_API
size_t RAPIER_CALL r2ContactPairs(const struct R2World *world,
                         struct R2ContactPair *buffer,
                         size_t capacity);

RAPIER_API
struct R2ContactPair RAPIER_CALL r2ContactPair(struct R2ColliderHandle collider1,
                                       struct R2ColliderHandle collider2);

RAPIER_API
size_t RAPIER_CALL r2IntersectionPairs(const struct R2World *world,
                              struct R2IntersectionPair *buffer,
                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2ContactPoints(struct R2ColliderHandle collider1,
                          struct R2ColliderHandle collider2,
                          struct R2ContactPoint *buffer,
                          size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2MultibodyJoint_GeneralizedVelocity(struct R2MultibodyJointHandle handle,
                                                R2Real *buffer,
                                                size_t capacity);

RAPIER_API
R2Status RAPIER_CALL r2MultibodyJoint_SetGeneralizedVelocity(struct R2MultibodyJointHandle handle,
                                                       const R2Real *values,
                                                       size_t count);

RAPIER_API
R2Status RAPIER_CALL r2CheckAbi(uint32_t version,
                        uint32_t dimension,
                        size_t real_size,
                        size_t vector_size,
                        size_t pose_size,
                        uint32_t features);

RAPIER_API
size_t RAPIER_CALL r2QuarantinedRigidBodies(const struct R2World *world,
                                    struct R2RigidBodyHandle *buffer,
                                    size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2QuarantinedColliders(const struct R2World *world,
                                 struct R2ColliderHandle *buffer,
                                 size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2QuarantinedSoftBodies(const struct R2World *world,
                                   struct R2SoftBodyHandle *buffer,
                                   size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API uint32_t RAPIER_CALL r2FrictionModel(const struct R2World *world);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R2Status RAPIER_CALL r2SetFrictionModel(struct R2World *world, uint32_t value);
#endif

RAPIER_API R2Real RAPIER_CALL r2Sin(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Cos(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Tan(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Asin(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Acos(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Atan2(R2Real y, R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Exp(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Ln(R2Real x);

RAPIER_API R2Real RAPIER_CALL r2Powf(R2Real base, R2Real exponent);

RAPIER_API
struct R2ShapeMesh *RAPIER_CALL r2SharedShape_Tessellate(const R2SharedShape *shape,
                                                 uint32_t subdivisions);

RAPIER_API
size_t RAPIER_CALL r2ShapeMesh_Triangles(const struct R2ShapeMesh *mesh,
                                struct R2Vector *buffer,
                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2ShapeMesh_Lines(const struct R2ShapeMesh *mesh,
                            struct R2Vector *buffer,
                            size_t capacity);

RAPIER_API R2Status RAPIER_CALL r2FreeShapeMesh(struct R2ShapeMesh *mesh);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2SharedShape *RAPIER_CALL r2RoundCylinderSharedShape(R2Real half_height,
                                                R2Real radius,
                                                R2Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2SharedShape *RAPIER_CALL r2RoundConeSharedShape(R2Real half_height,
                                            R2Real radius,
                                            R2Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2TriMeshData *RAPIER_CALL r2SharedShape_ToTrimesh(const R2SharedShape *shape,
                                                   uint32_t ntheta,
                                                   uint32_t nphi);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r2TriMeshData_Vertices(const struct R2TriMeshData *mesh,
                                  struct R2Vector *buffer,
                                  size_t capacity);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r2TriMeshData_Indices(const struct R2TriMeshData *mesh,
                                 uint32_t *buffer,
                                 size_t capacity);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R2Status RAPIER_CALL r2FreeTriMeshData(struct R2TriMeshData *mesh);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R2UrdfLoaderOptions RAPIER_CALL r2DefaultUrdfLoaderOptions(void);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeUrdfRobot(struct R2UrdfRobot *object);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2UrdfRobot *RAPIER_CALL r2UrdfRobotFromFile(const char *path,
                                              const struct R2UrdfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2UrdfRobot_AppendTransform(struct R2UrdfRobot *robot,
                                          struct R2Pose transform);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeUrdfRobotHandles(struct R2UrdfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2UrdfRobotHandles *RAPIER_CALL r2UrdfRobot_InsertUsingImpulseJoints(struct R2World *world,
                                                                       const struct R2UrdfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2UrdfRobotHandles *RAPIER_CALL r2UrdfRobot_InsertUsingMultibodyJoints(struct R2World *world,
                                                                         const struct R2UrdfRobot *robot,
                                                                         uint8_t options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2UrdfRobotHandles_Bodies(const struct R2UrdfRobotHandles *handles,
                                     struct R2RigidBodyHandle *buffer,
                                     size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R2MjcfLoaderOptions RAPIER_CALL r2DefaultMjcfLoaderOptions(void);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeMjcfRobot(struct R2MjcfRobot *object);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2MjcfRobot *RAPIER_CALL r2MjcfRobotFromFile(const char *path,
                                              const struct R2MjcfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2MjcfRobot_AppendTransform(struct R2MjcfRobot *robot,
                                          struct R2Pose transform);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeMjcfRobotHandles(struct R2MjcfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2MjcfRobotHandles *RAPIER_CALL r2MjcfRobot_InsertUsingImpulseJoints(struct R2World *world,
                                                                       const struct R2MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2MjcfRobotHandles *RAPIER_CALL r2MjcfRobot_InsertUsingMultibodyJoints(struct R2World *world,
                                                                         const struct R2MjcfRobot *robot,
                                                                         uint8_t options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfRobotHandles_Bodies(const struct R2MjcfRobotHandles *handles,
                                     struct R2RigidBodyHandle *buffer,
                                     size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R2Vector RAPIER_CALL r2MjcfRobot_Gravity(const struct R2MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2MjcfRobot_BodyCount(const struct R2MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2MjcfRobot_BodyColliderCount(const struct R2MjcfRobot *robot, size_t body);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2MjcfRobot_SetBodyColliderCollisionGroups(struct R2MjcfRobot *robot,
                                                            size_t body,
                                                            size_t collider,
                                                            struct R2InteractionGroups groups);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2MjcfRobot_KeyframeCount(const struct R2MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfRobot_KeyframeName(const struct R2MjcfRobot *robot,
                                    size_t key,
                                    char *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2MjcfRobot_AppendKeyframe(struct R2MjcfRobot *robot,
                                         const struct R2MjcfRobot *source,
                                         size_t key);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfRobot_KeyframeControls(const struct R2MjcfRobot *robot,
                                        size_t key,
                                        R2Real *buffer,
                                        size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2MjcfRobotHandles_ActuatorCount(const struct R2MjcfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2MjcfRobotHandles_ApplyKeyframe(const struct R2MjcfRobotHandles *handles,
                                                const struct R2MjcfRobot *robot,
                                                size_t key);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2Status RAPIER_CALL r2MjcfRobotHandles_ApplyControlsScaled(const struct R2MjcfRobotHandles *handles,
                                                       const R2Real *controls,
                                                       size_t count,
                                                       R2Real gain);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2MjcfRobot_BodyVisualCount(const struct R2MjcfRobot *robot, size_t body);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
const R2MjcfVisualMesh *RAPIER_CALL r2MjcfRobot_BodyVisual(const struct R2MjcfRobot *robot,
                                                    size_t body,
                                                    size_t visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R2MjcfVisualMeshInfo RAPIER_CALL r2MjcfVisualMesh_Info(const R2MjcfVisualMesh *visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2SharedShape *RAPIER_CALL r2MjcfVisualMesh_CloneShape(const R2MjcfVisualMesh *visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfVisualMesh_Uvs(const R2MjcfVisualMesh *visual,
                                float *buffer,
                                size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfVisualMesh_Normals(const R2MjcfVisualMesh *visual,
                                    float *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r2MjcfVisualMesh_Texture(const R2MjcfVisualMesh *visual,
                                    char *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2UrdfRobot *RAPIER_CALL r2UrdfRobotFromString(const char *urdf,
                                                const char *mesh_dir,
                                                const struct R2UrdfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeMjcfContactHooks(struct R2MjcfContactHooks *hooks);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2MjcfContactHooks *RAPIER_CALL r2MjcfRobotHandles_ContactHooks(const struct R2MjcfRobotHandles *handles,
                                                                 const struct R2MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2PhysicsHooks RAPIER_CALL r2MjcfContactHooks_PhysicsHooks(const struct R2MjcfContactHooks *hooks);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R2Status RAPIER_CALL r2FreeLoadedMeshes(struct R2LoadedMeshes *meshes);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2LoadedMeshes *RAPIER_CALL r2LoadedMeshesFromFile(const char *path,
                                                    uint32_t converter,
                                                    uint32_t trimesh_flags,
                                                    struct R2Vector scale);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r2LoadedMeshes_Count(const struct R2LoadedMeshes *meshes);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R2SharedShape *RAPIER_CALL r2LoadedMeshes_CloneShape(const struct R2LoadedMeshes *meshes,
                                              size_t index);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R2Pose RAPIER_CALL r2LoadedMeshes_Pose(const struct R2LoadedMeshes *meshes,
                                      size_t index);
#endif

RAPIER_API struct R2Pose RAPIER_CALL r2RigidBody_Position(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2RigidBody_Translation(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2RigidBody_Linvel(struct R2RigidBodyHandle handle);

RAPIER_API R2AngVector RAPIER_CALL r2RigidBody_Angvel(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsSleeping(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsEnabled(struct R2RigidBodyHandle handle);

RAPIER_API struct R2UserData RAPIER_CALL r2RigidBody_UserData(struct R2RigidBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetPosition(struct R2RigidBodyHandle handle,
                                      struct R2Pose value,
                                      R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetTranslation(struct R2RigidBodyHandle handle,
                                         struct R2Vector value,
                                         R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetLinvel(struct R2RigidBodyHandle handle,
                                    struct R2Vector value,
                                    R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAngvel(struct R2RigidBodyHandle handle,
                                    R2AngVector value,
                                    R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetNextKinematicPosition(struct R2RigidBodyHandle handle,
                                                     struct R2Pose value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetNextKinematicTranslation(struct R2RigidBodyHandle handle,
                                                        struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetGravityScale(struct R2RigidBodyHandle handle,
                                           R2Real value,
                                           R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetLinearDamping(struct R2RigidBodyHandle handle,
                                            R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAngularDamping(struct R2RigidBodyHandle handle,
                                             R2Real value);

RAPIER_API R2Status RAPIER_CALL r2RigidBody_SetEnabled(struct R2RigidBodyHandle handle, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetUserData(struct R2RigidBodyHandle handle,
                                       struct R2UserData value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_ApplyImpulse(struct R2RigidBodyHandle handle,
                                       struct R2Vector value,
                                       R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_ApplyImpulseAtPoint(struct R2RigidBodyHandle handle,
                                                struct R2Vector value,
                                                struct R2Vector point,
                                                R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_AddForce(struct R2RigidBodyHandle handle,
                                   struct R2Vector value,
                                   R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2RigidBody_ResetForces(struct R2RigidBodyHandle handle, R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2RigidBody_Sleep(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Pose RAPIER_CALL r2Collider_Position(struct R2ColliderHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2Collider_Translation(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_Friction(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_Restitution(struct R2ColliderHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2Collider_IsSensor(struct R2ColliderHandle handle);

RAPIER_API struct R2RigidBodyHandle RAPIER_CALL r2Collider_Parent(struct R2ColliderHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetPosition(struct R2ColliderHandle handle,
                                    struct R2Pose value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetTranslation(struct R2ColliderHandle handle,
                                       struct R2Vector value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetFriction(struct R2ColliderHandle handle, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetRestitution(struct R2ColliderHandle handle, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetSensor(struct R2ColliderHandle handle, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetCollisionGroups(struct R2ColliderHandle handle,
                                            struct R2InteractionGroups value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetUserData(struct R2ColliderHandle handle,
                                     struct R2UserData value);

RAPIER_API
struct R2Vector RAPIER_CALL r2SoftBody_ParticlePosition(struct R2SoftBodyHandle handle,
                                                 size_t index);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_ParticlePositions(struct R2SoftBodyHandle handle,
                                        struct R2Vector *buffer,
                                        size_t capacity);

RAPIER_API struct R2SoftBodyMaterial RAPIER_CALL r2SoftBody_Material(struct R2SoftBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetParticlePosition(struct R2SoftBodyHandle handle,
                                              size_t index,
                                              struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetMaterial(struct R2SoftBodyHandle handle,
                                     const struct R2SoftBodyMaterial *data);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_AddParticleForce(struct R2SoftBodyHandle handle,
                                           size_t index,
                                           struct R2Vector value,
                                           R2Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r2RigidBodyReadStates(const struct R2World *world,
                                  const struct R2RigidBodyHandle *handles,
                                  size_t handle_count,
                                  struct R2RigidBodyState *states,
                                  size_t capacity);

RAPIER_API struct R2JointDesc RAPIER_CALL r2ImpulseJoint_Desc(struct R2ImpulseJointHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetDesc(struct R2ImpulseJointHandle handle,
                                     const struct R2JointDesc *desc,
                                     R2Bool wake_up);

RAPIER_API uint16_t RAPIER_CALL r2Collider_ActiveCollisionTypes(struct R2ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2Collider_ActiveHooks(struct R2ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2Collider_FrictionCombineRule(struct R2ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2Collider_RestitutionCombineRule(struct R2ColliderHandle handle);

RAPIER_API struct R2Pose RAPIER_CALL r2Collider_PositionWrtParent(struct R2ColliderHandle handle);

RAPIER_API int8_t RAPIER_CALL r2RigidBody_DominanceGroup(struct R2RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r2RigidBody_AdditionalSolverIterations(struct R2RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r2RigidBody_AdditionalPgsIterations(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsFastRotationAllowed(struct R2RigidBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetRotation(struct R2ColliderHandle handle,
                                    struct R2Rotation value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAllowFastRotation(struct R2RigidBodyHandle handle,
                                                 R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2ShapeDesc_SetTrimesh(struct R2ShapeDesc *desc,
                                     struct R2VectorView vertices,
                                     struct R2TriangleView indices,
                                     uint32_t flags);

RAPIER_API
R2Status RAPIER_CALL r2ShapeDesc_SetPolyline(struct R2ShapeDesc *desc,
                                      struct R2VectorView vertices,
                                      struct R2EdgeView indices,
                                      uint32_t flags);

RAPIER_API
R2Status RAPIER_CALL r2ShapeDesc_SetConvexHull(struct R2ShapeDesc *desc,
                                         struct R2VectorView vertices);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetParticles(struct R2SoftBodyDesc *desc,
                                           struct R2VectorView positions);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetSurfaceMesh(struct R2SoftBodyDesc *desc,
                                              struct R2VectorView vertices,
                                              R2SurfaceElementView elements);
 
#if defined(RAPIER_DIM2)
RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetTrimesh(struct R2SoftBodyDesc *desc,
                                         struct R2VectorView vertices,
                                         struct R2TriangleView triangles);
#endif

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetAppended(struct R2SoftBodyDesc *desc,
                                          struct R2SoftBodyDescView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetAddedEdges(struct R2SoftBodyDesc *desc,
                                             struct R2EdgeView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetSkin(struct R2SoftBodyDesc *desc,
                                      struct R2VectorView vertices,
                                      R2SurfaceElementView elements);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetMasses(struct R2SoftBodyDesc *desc,
                                        struct R2RealView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetPinnedParticles(struct R2SoftBodyDesc *desc,
                                                  struct R2IndexView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetEdges(struct R2SoftBodyDesc *desc,
                                       struct R2EdgeView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetBendEdges(struct R2SoftBodyDesc *desc,
                                            struct R2EdgeView view);

RAPIER_API R2Status RAPIER_CALL r2SoftBodyDesc_SetCells(struct R2SoftBodyDesc *desc, R2CellView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetSurface(struct R2SoftBodyDesc *desc,
                                         R2SurfaceElementView view);

RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetTensionOnlyEdges(struct R2SoftBodyDesc *desc,
                                                    struct R2IndexView view);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetDihedrals(struct R2SoftBodyDesc *desc,
                                           struct R2DihedralView view);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2SoftBodyDesc_SetWire(struct R2SoftBodyDesc *desc,
                                      struct R2EdgeView view);
#endif

RAPIER_API
struct R2ColliderDesc RAPIER_CALL r2RoundCuboidColliderDesc(struct R2Vector half_extents,
                                                      R2Real border_radius);

RAPIER_API
struct R2ColliderDesc RAPIER_CALL r2CapsuleColliderDesc(struct R2Vector a,
                                                 struct R2Vector b,
                                                 R2Real radius);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2SegmentColliderDesc(struct R2Vector a, struct R2Vector b);

RAPIER_API
struct R2ColliderDesc RAPIER_CALL r2TriangleColliderDesc(struct R2Vector a,
                                                  struct R2Vector b,
                                                  struct R2Vector c);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2HalfspaceColliderDesc(struct R2Vector normal);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2ColliderDesc RAPIER_CALL r2CylinderColliderDesc(R2Real half_height, R2Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2ColliderDesc RAPIER_CALL r2ConeColliderDesc(R2Real half_height, R2Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2ColliderDesc RAPIER_CALL r2RoundCylinderColliderDesc(R2Real half_height,
                                                        R2Real radius,
                                                        R2Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2ColliderDesc RAPIER_CALL r2RoundConeColliderDesc(R2Real half_height,
                                                    R2Real radius,
                                                    R2Real border_radius);
#endif

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2CapsuleXColliderDesc(R2Real half_height, R2Real radius);

RAPIER_API struct R2ColliderDesc RAPIER_CALL r2CapsuleYColliderDesc(R2Real half_height, R2Real radius);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R2ColliderDesc RAPIER_CALL r2CapsuleZColliderDesc(R2Real half_height, R2Real radius);
#endif

RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2RopeSoftBodyDesc(struct R2Vector a,
                                               struct R2Vector b,
                                               size_t particles);
 
#if defined(RAPIER_DIM2)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2GridSoftBodyDesc(struct R2Vector center,
                                               struct R2Vector half_extents,
                                               size_t nx,
                                               size_t ny);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2CuboidSoftBodyDesc(struct R2Vector center,
                                                 struct R2Vector half_extents,
                                                 size_t nx,
                                                 size_t ny,
                                                 size_t nz);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2ClothSoftBodyDesc(struct R2Vector origin,
                                                struct R2Vector du,
                                                struct R2Vector dv,
                                                size_t nu,
                                                size_t nv);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2ClothAnisotropicSoftBodyDesc(struct R2Vector origin,
                                                            struct R2Vector du,
                                                            struct R2Vector dv,
                                                            size_t nu,
                                                            size_t nv,
                                                            struct R2SpringCoefficients warp,
                                                            struct R2SpringCoefficients weft,
                                                            struct R2SpringCoefficients shear);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R2SoftBodyDesc RAPIER_CALL r2PolygonSoftBodyDesc(struct R2VectorView points);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2DiskSoftBodyDesc(struct R2Vector center,
                                               R2Real radius,
                                               size_t particles);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2SphereSoftBodyDesc(struct R2Vector center,
                                                 R2Real radius,
                                                 uint32_t subdivisions);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2ClothTubeSoftBodyDesc(struct R2Vector origin,
                                                     struct R2Vector axis,
                                                     R2Real radius_start,
                                                     R2Real radius_end,
                                                     size_t num_around,
                                                     size_t num_along);
#endif

RAPIER_API
struct R2SoftBodyDesc RAPIER_CALL r2VolumetricSoftBodyDesc(struct R2VectorView vertices,
                                                     R2SurfaceElementView surface,
                                                     struct R2VolumeMeshParameters parameters);

RAPIER_API
struct R2SoftBodyMaterial RAPIER_CALL r2UniformSoftBodyMaterial(struct R2SpringCoefficients value);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyDesc_ParticlePositions(const struct R2SoftBodyDesc *desc,
                                             struct R2Vector *buffer,
                                             size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBodyDesc_CellIndices(const struct R2SoftBodyDesc *desc,
                                       uint32_t *buffer,
                                       size_t capacity);

RAPIER_API
struct R2Vector RAPIER_CALL r2SoftBody_ParticleVelocity(struct R2SoftBodyHandle handle,
                                                 size_t index);

RAPIER_API uint32_t RAPIER_CALL r2SoftBody_Solver(struct R2SoftBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterEdgeSoftness(struct R2SoftBodyHandle handle,
                                                  uint32_t cluster,
                                                  const struct R2SpringCoefficients *softness);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_ApplyImpulseAtPoint(struct R2SoftBodyHandle handle,
                                               struct R2Vector impulse,
                                               struct R2Vector point,
                                               R2Real falloff_radius,
                                               R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_ApplyRadialImpulse(struct R2SoftBodyHandle handle,
                                             struct R2Vector center,
                                             R2Real magnitude,
                                             R2Real falloff_radius,
                                             R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_ResetPlasticity(struct R2SoftBodyHandle handle);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_TearEdge(struct R2SoftBodyHandle handle, size_t index);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_TearCell(struct R2SoftBodyHandle handle, size_t index);

RAPIER_API struct R2SoftBodyHandle RAPIER_CALL r2Collider_SoftBody(struct R2ColliderHandle handle);

RAPIER_API
struct R2SoftBodyHandle RAPIER_CALL r2ReadCollider_SoftBody(const struct R2ReadContext *context,
                                                     struct R2ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r2SoftBodyTearEvent_PieceCount(const struct R2SoftBodyTearEvent *event);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryAuthoredVelocityMargin(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryEdgeSpeculation(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryInvertedCellDetection(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoverySelfCrossingDetection(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryDetectionMotionGating(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryCrossBodyDetection(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoverySelfStandDown(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryCrossBodyExpelGate(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryEdgeStandDown(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryCrossingRepulsion(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryCrossingRepulsionGuide(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryCrossingRepulsionSelfGuide(const struct R2World *world);

RAPIER_API R2Real RAPIER_CALL r2RecoveryRecoveryPace(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapConstraints(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapRigid(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapSkipSelfTangled(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapEdgeStandDown(const struct R2World *world);

RAPIER_API R2Real RAPIER_CALL r2RecoveryOverlapConstraintPace(const struct R2World *world);

RAPIER_API uint32_t RAPIER_CALL r2RecoveryOverlapPatchConstraints(const struct R2World *world);

RAPIER_API
R2Status RAPIER_CALL r2RecoverySetOverlapPatchConstraints(struct R2World *world,
                                                     uint32_t value);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapSkinVolume(const struct R2World *world);

RAPIER_API R2Real RAPIER_CALL r2RecoveryOverlapKeptDepth(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapSelfRegions(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapNormalPush(const struct R2World *world);

RAPIER_API R2Bool RAPIER_CALL r2RecoveryOverlapMultiVolume(const struct R2World *world);

RAPIER_API uint32_t RAPIER_CALL r2RecoveryOverlapSplit(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapSplit(struct R2World *world, uint32_t value);

RAPIER_API uint32_t RAPIER_CALL r2RecoveryOverlapPatience(const struct R2World *world);

RAPIER_API R2Status RAPIER_CALL r2RecoverySetOverlapPatience(struct R2World *world, uint32_t value);

RAPIER_API R2Real RAPIER_CALL r2RecoveryOverlapProgressMargin(const struct R2World *world);
 
#if defined(RAPIER_FEM)
RAPIER_API R2Real RAPIER_CALL r2FemLinearTolerance(const struct R2World *world);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API size_t RAPIER_CALL r2FemMaxLinearIterations(const struct R2World *world);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API size_t RAPIER_CALL r2FemMaxDenseDofs(const struct R2World *world);
#endif

RAPIER_API size_t RAPIER_CALL r2Collider_ShapeIdentity(struct R2ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r2SoftBody_NumParticles(struct R2SoftBodyHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2SoftBody_TopologyVersion(struct R2SoftBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2SoftBody_Mass(struct R2SoftBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2SoftBody_Volume(struct R2SoftBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2SoftBody_RestVolume(struct R2SoftBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2SoftBody_VolumeFactor(struct R2SoftBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2SoftBody_CenterOfMass(struct R2SoftBodyHandle handle);

RAPIER_API struct R2RigidBodyHandle RAPIER_CALL r2SoftBody_RootBody(struct R2SoftBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2SoftBody_IsEnabled(struct R2SoftBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2SoftBody_IsSleeping(struct R2SoftBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_ParticleVelocities(struct R2SoftBodyHandle handle,
                                         struct R2Vector *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Edges(struct R2SoftBodyHandle handle,
                           uint32_t *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Cells(struct R2SoftBodyHandle handle,
                           uint32_t *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Boundary(struct R2SoftBodyHandle handle,
                              uint32_t *buffer,
                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Pieces(struct R2SoftBodyHandle handle,
                            struct R2SoftBodyHandle *buffer,
                            size_t capacity);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetParticleVelocity(struct R2SoftBodyHandle handle,
                                              size_t index,
                                              struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetParticleKinematicTarget(struct R2SoftBodyHandle handle,
                                                      size_t index,
                                                      struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetParticlePinned(struct R2SoftBodyHandle handle,
                                            size_t index,
                                            R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_ApplyParticleImpulse(struct R2SoftBodyHandle handle,
                                               size_t index,
                                               struct R2Vector value,
                                               R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_AddForce(struct R2SoftBodyHandle handle,
                                  struct R2Vector value,
                                  R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_ApplyImpulse(struct R2SoftBodyHandle handle,
                                      struct R2Vector value,
                                      R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_ResetForces(struct R2SoftBodyHandle handle, R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_SetEnabled(struct R2SoftBodyHandle handle, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetVolumeFactor(struct R2SoftBodyHandle handle,
                                          R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_AttachParticle(struct R2SoftBodyHandle handle,
                                        size_t index,
                                        struct R2RigidBodyHandle rigid_body);

RAPIER_API R2Bool RAPIER_CALL r2SoftBody_DetachParticle(struct R2SoftBodyHandle handle, size_t index);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Clusters(struct R2SoftBodyHandle handle,
                              uint32_t *buffer,
                              size_t capacity);

RAPIER_API
struct R2RigidBodyHandle RAPIER_CALL r2SoftBody_ClusterProxy(struct R2SoftBodyHandle handle,
                                                      uint32_t cluster);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_ClusterParticles(struct R2SoftBodyHandle handle,
                                       uint32_t cluster,
                                       uint32_t *buffer,
                                       size_t capacity);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterPinned(struct R2SoftBodyHandle handle,
                                           uint32_t cluster,
                                           R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterKinematicTarget(struct R2SoftBodyHandle handle,
                                                     uint32_t cluster,
                                                     struct R2Pose value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterShapeMatchingEnabled(struct R2SoftBodyHandle handle,
                                                           uint32_t cluster,
                                                           R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterStiffnessScale(struct R2SoftBodyHandle handle,
                                                    uint32_t cluster,
                                                    R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterTearResistance(struct R2SoftBodyHandle handle,
                                                    uint32_t cluster,
                                                    R2Real value);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_Meshes(struct R2SoftBodyHandle handle,
                            struct R2SoftMeshInfo *buffer,
                            size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshVerticesById(struct R2SoftBodyHandle handle,
                                         struct R2SoftMeshId id,
                                         struct R2Vector *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshIndicesById(struct R2SoftBodyHandle handle,
                                        struct R2SoftMeshId id,
                                        uint32_t *buffer,
                                        size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshColliders(struct R2SoftBodyHandle handle,
                                    struct R2ColliderHandle *buffer,
                                    size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshVertices(struct R2SoftBodyHandle handle,
                                   struct R2ColliderHandle collider,
                                   struct R2Vector *buffer,
                                   size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshIndices(struct R2SoftBodyHandle handle,
                                  struct R2ColliderHandle collider,
                                  uint32_t *buffer,
                                  size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SoftBody_MeshArity(struct R2SoftBodyHandle handle,
                                struct R2ColliderHandle collider);

RAPIER_API
uint32_t RAPIER_CALL r2SoftBody_MeshTopologyVersion(struct R2SoftBodyHandle handle,
                                             struct R2ColliderHandle collider);
 
#if defined(RAPIER_FEM)
RAPIER_API R2Status RAPIER_CALL r2SoftBody_SetSolver(struct R2SoftBodyHandle handle, uint32_t solver);
#endif

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetClusterShapeMatchingTarget(struct R2SoftBodyHandle handle,
                                                          uint32_t cluster,
                                                          const struct R2Pose *target);

RAPIER_API
R2Status RAPIER_CALL r2SoftBody_SetEdgeTearResistance(struct R2SoftBodyHandle handle,
                                                 size_t index,
                                                 R2Real resistance);

RAPIER_API
R2Bool RAPIER_CALL r2SoftBody_MeshIsClosed(struct R2SoftBodyHandle handle,
                                     struct R2ColliderHandle collider);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAdditionalMassProperties(struct R2RigidBodyHandle handle,
                                                        struct R2MassProperties properties,
                                                        R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_RecomputeMassPropertiesFromColliders(struct R2RigidBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetMassProperties(struct R2ColliderHandle handle,
                                           struct R2MassProperties properties);

RAPIER_API struct R2MassProperties RAPIER_CALL r2Collider_MassProperties(struct R2ColliderHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetLockedAxes(struct R2RigidBodyHandle handle,
                                         uint8_t axes,
                                         R2Bool wake_up);

RAPIER_API uint8_t RAPIER_CALL r2RigidBody_LockedAxes(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2Collider_IsVoxels(struct R2ColliderHandle handle);

RAPIER_API
struct R2VoxelQuery RAPIER_CALL r2Collider_VoxelAtFlatId(struct R2ColliderHandle handle,
                                                   uint32_t id);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetVoxel(struct R2ColliderHandle handle,
                                 struct R2VoxelKey key,
                                 R2Bool filled);

RAPIER_API struct R2Pose RAPIER_CALL r2RigidBody_NextPosition(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Rotation RAPIER_CALL r2RigidBody_Rotation(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2RigidBody_CenterOfMass(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2RigidBody_LocalCenterOfMass(struct R2RigidBodyHandle handle);

RAPIER_API struct R2Vector RAPIER_CALL r2RigidBody_UserForce(struct R2RigidBodyHandle handle);

RAPIER_API R2AngVector RAPIER_CALL r2RigidBody_UserTorque(struct R2RigidBodyHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2RigidBody_BodyType(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_Mass(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_GravityScale(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_LinearDamping(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_AngularDamping(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_KineticEnergy(struct R2RigidBodyHandle handle);

RAPIER_API R2Real RAPIER_CALL r2RigidBody_SoftCcdPrediction(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsCcdEnabled(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsDynamic(struct R2RigidBodyHandle handle);

RAPIER_API struct R2SoftBodyHandle RAPIER_CALL r2RigidBody_SoftBody(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsSoftFrame(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsFixed(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsKinematic(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsMoving(struct R2RigidBodyHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2RigidBody_IsCcdActive(struct R2RigidBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetRotation(struct R2RigidBodyHandle handle,
                                      struct R2Rotation value,
                                      R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetBodyType(struct R2RigidBodyHandle handle,
                                       uint32_t value,
                                       R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetNextKinematicRotation(struct R2RigidBodyHandle handle,
                                                     struct R2Rotation value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAdditionalMass(struct R2RigidBodyHandle handle,
                                             R2Real value,
                                             R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetSoftCcdPrediction(struct R2RigidBodyHandle handle,
                                                 R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetCcdEnabled(struct R2RigidBodyHandle handle,
                                         R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetTranslationsLocked(struct R2RigidBodyHandle handle,
                                                 R2Bool value,
                                                 R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetRotationsLocked(struct R2RigidBodyHandle handle,
                                              R2Bool value,
                                              R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetDominanceGroup(struct R2RigidBodyHandle handle,
                                             int8_t value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAdditionalSolverIterations(struct R2RigidBodyHandle handle,
                                                          size_t value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetAdditionalPgsIterations(struct R2RigidBodyHandle handle,
                                                       size_t value);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_AddTorque(struct R2RigidBodyHandle handle,
                                    R2AngVector value,
                                    R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_ApplyTorqueImpulse(struct R2RigidBodyHandle handle,
                                              R2AngVector value,
                                              R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_AddForceAtPoint(struct R2RigidBodyHandle handle,
                                            struct R2Vector value,
                                            struct R2Vector point,
                                            R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2RigidBody_ResetTorques(struct R2RigidBodyHandle handle,
                                       R2Bool wake_up);

RAPIER_API
struct R2Vector RAPIER_CALL r2RigidBody_VelocityAtPoint(struct R2RigidBodyHandle handle,
                                                  struct R2Vector point);

RAPIER_API
size_t RAPIER_CALL r2RigidBody_Colliders(struct R2RigidBodyHandle handle,
                                struct R2ColliderHandle *buffer,
                                size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API R2Bool RAPIER_CALL r2RigidBody_GyroscopicForcesEnabled(struct R2RigidBodyHandle handle);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Status RAPIER_CALL r2RigidBody_SetGyroscopicForcesEnabled(struct R2RigidBodyHandle handle,
                                                       R2Bool enabled);
#endif

RAPIER_API R2Status RAPIER_CALL r2Collider_SetDensity(struct R2ColliderHandle handle, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetMass(struct R2ColliderHandle handle, R2Real value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetEnabled(struct R2ColliderHandle handle, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetSolverGroups(struct R2ColliderHandle handle,
                                         struct R2InteractionGroups value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetFrictionCombineRule(struct R2ColliderHandle handle,
                                                 uint32_t value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetRestitutionCombineRule(struct R2ColliderHandle handle,
                                                    uint32_t value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetContactSkin(struct R2ColliderHandle handle, R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetContactForceEventThreshold(struct R2ColliderHandle handle,
                                                         R2Real value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetActiveEvents(struct R2ColliderHandle handle,
                                         uint32_t value);

RAPIER_API R2Status RAPIER_CALL r2Collider_SetActiveHooks(struct R2ColliderHandle handle, uint32_t value);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetActiveCollisionTypes(struct R2ColliderHandle handle,
                                                  uint16_t value);

RAPIER_API struct R2Rotation RAPIER_CALL r2Collider_Rotation(struct R2ColliderHandle handle);

RAPIER_API
struct R2InteractionGroups RAPIER_CALL r2Collider_CollisionGroups(struct R2ColliderHandle handle);

RAPIER_API struct R2InteractionGroups RAPIER_CALL r2Collider_SolverGroups(struct R2ColliderHandle handle);

RAPIER_API struct R2UserData RAPIER_CALL r2Collider_UserData(struct R2ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r2Collider_ActiveEvents(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_Mass(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_Density(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_Volume(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_ContactSkin(struct R2ColliderHandle handle);

RAPIER_API R2Real RAPIER_CALL r2Collider_ContactForceEventThreshold(struct R2ColliderHandle handle);

RAPIER_API R2Bool RAPIER_CALL r2Collider_IsEnabled(struct R2ColliderHandle handle);

RAPIER_API struct R2Aabb RAPIER_CALL r2Collider_ComputeAabb(struct R2ColliderHandle handle);

RAPIER_API R2SharedShape *RAPIER_CALL r2Collider_CloneShape(struct R2ColliderHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetShape(struct R2ColliderHandle handle,
                                 const R2SharedShape *shape);

RAPIER_API
R2Status RAPIER_CALL r2Collider_SetPositionWrtParent(struct R2ColliderHandle handle,
                                               struct R2Pose value);

RAPIER_API R2Status RAPIER_CALL r2RigidBody_ValidateHandle(struct R2RigidBodyHandle handle);

RAPIER_API R2Status RAPIER_CALL r2Collider_ValidateHandle(struct R2ColliderHandle handle);

RAPIER_API R2Status RAPIER_CALL r2SoftBody_ValidateHandle(struct R2SoftBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalFrame1(struct R2JointDesc *desc,
                                          struct R2Pose value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalFrame1(struct R2ImpulseJointHandle handle,
                                             struct R2Pose value,
                                             R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalFrame2(struct R2JointDesc *desc,
                                          struct R2Pose value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalFrame2(struct R2ImpulseJointHandle handle,
                                             struct R2Pose value,
                                             R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalAnchor1(struct R2JointDesc *desc,
                                           struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalAnchor1(struct R2ImpulseJointHandle handle,
                                              struct R2Vector value,
                                              R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalAnchor2(struct R2JointDesc *desc,
                                           struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalAnchor2(struct R2ImpulseJointHandle handle,
                                              struct R2Vector value,
                                              R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetContactsEnabled(struct R2JointDesc *desc, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetContactsEnabled(struct R2ImpulseJointHandle handle,
                                                 R2Bool value,
                                                 R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetEnabled(struct R2JointDesc *desc, R2Bool value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetEnabled(struct R2ImpulseJointHandle handle,
                                        R2Bool value,
                                        R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetSoftness(struct R2JointDesc *desc,
                                      struct R2SpringCoefficients value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetSoftness(struct R2ImpulseJointHandle handle,
                                         struct R2SpringCoefficients value,
                                         R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetLockedAxes(struct R2JointDesc *desc, uint8_t value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLockedAxes(struct R2ImpulseJointHandle handle,
                                            uint8_t value,
                                            R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetLimitAxes(struct R2JointDesc *desc, uint8_t value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLimitAxes(struct R2ImpulseJointHandle handle,
                                           uint8_t value,
                                           R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetMotorAxes(struct R2JointDesc *desc, uint8_t value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotorAxes(struct R2ImpulseJointHandle handle,
                                           uint8_t value,
                                           R2Bool wake_up);

RAPIER_API R2Status RAPIER_CALL r2JointDesc_SetCoupledAxes(struct R2JointDesc *desc, uint8_t value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetCoupledAxes(struct R2ImpulseJointHandle handle,
                                             uint8_t value,
                                             R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalAxis1(struct R2JointDesc *desc,
                                         struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalAxis1(struct R2ImpulseJointHandle handle,
                                            struct R2Vector value,
                                            R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLocalAxis2(struct R2JointDesc *desc,
                                         struct R2Vector value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLocalAxis2(struct R2ImpulseJointHandle handle,
                                            struct R2Vector value,
                                            R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetLimits(struct R2JointDesc *desc,
                                    uint32_t joint_axis,
                                    R2Real min,
                                    R2Real max);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetLimits(struct R2ImpulseJointHandle handle,
                                       uint32_t joint_axis,
                                       R2Real min,
                                       R2Real max,
                                       R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetMotor(struct R2JointDesc *desc,
                                   uint32_t joint_axis,
                                   R2Real target_position,
                                   R2Real target_velocity,
                                   R2Real stiffness,
                                   R2Real damping);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotor(struct R2ImpulseJointHandle handle,
                                      uint32_t joint_axis,
                                      R2Real target_position,
                                      R2Real target_velocity,
                                      R2Real stiffness,
                                      R2Real damping,
                                      R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetMotorMaxForce(struct R2JointDesc *desc,
                                             uint32_t joint_axis,
                                             R2Real max_force);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotorMaxForce(struct R2ImpulseJointHandle handle,
                                                uint32_t joint_axis,
                                                R2Real max_force,
                                                R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetMotorModel(struct R2JointDesc *desc,
                                         uint32_t joint_axis,
                                         uint32_t model);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotorModel(struct R2ImpulseJointHandle handle,
                                            uint32_t joint_axis,
                                            uint32_t model,
                                            R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetUserData(struct R2JointDesc *desc,
                                       struct R2UserData value);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetUserData(struct R2ImpulseJointHandle handle,
                                          struct R2UserData value,
                                          R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetMotorPosition(struct R2JointDesc *desc,
                                            uint32_t joint_axis,
                                            R2Real target_position,
                                            R2Real stiffness,
                                            R2Real damping);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotorPosition(struct R2ImpulseJointHandle handle,
                                               uint32_t joint_axis,
                                               R2Real target_position,
                                               R2Real stiffness,
                                               R2Real damping,
                                               R2Bool wake_up);

RAPIER_API
R2Status RAPIER_CALL r2JointDesc_SetMotorVelocity(struct R2JointDesc *desc,
                                            uint32_t joint_axis,
                                            R2Real target_velocity,
                                            R2Real factor);

RAPIER_API
R2Status RAPIER_CALL r2ImpulseJoint_SetMotorVelocity(struct R2ImpulseJointHandle handle,
                                               uint32_t joint_axis,
                                               R2Real target_velocity,
                                               R2Real factor,
                                               R2Bool wake_up);

RAPIER_API struct R2JointImpulses RAPIER_CALL r2ImpulseJoint_Impulses(struct R2ImpulseJointHandle handle);

RAPIER_API struct R2UserData RAPIER_CALL r2ImpulseJoint_UserData(struct R2ImpulseJointHandle handle);

RAPIER_API size_t RAPIER_CALL r2ImpulseJointCount(const struct R2World *world);

RAPIER_API size_t RAPIER_CALL r2MultibodyJointCount(const struct R2World *world);

RAPIER_API struct R2JointDesc RAPIER_CALL r2MultibodyJoint_Desc(struct R2MultibodyJointHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2MultibodyJoint_SetDesc(struct R2MultibodyJointHandle handle,
                                       const struct R2JointDesc *desc,
                                       R2Bool wake_up);

RAPIER_API struct R2JointBodies RAPIER_CALL r2MultibodyJoint_Bodies(struct R2MultibodyJointHandle handle);

RAPIER_API
R2SharedShape *RAPIER_CALL r2ConvexDecompositionSharedShape(struct R2VectorView vertices,
                                                      R2SurfaceElementView indices);

RAPIER_API
R2SharedShape *RAPIER_CALL r2VoxelsSharedShapeFromPoints(struct R2Vector voxel_size,
                                                    struct R2VectorView points);

RAPIER_API
R2SharedShape *RAPIER_CALL r2VoxelizedMeshSharedShape(struct R2VectorView vertices,
                                                R2SurfaceElementView indices,
                                                R2Real voxel_size);

RAPIER_API R2SharedShape *RAPIER_CALL r2ConvexHullSharedShape(struct R2VectorView vertices);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2SharedShape *RAPIER_CALL r2ConvexMeshSharedShape(struct R2VectorView vertices,
                                             struct R2TriangleView indices);
#endif

RAPIER_API
R2SharedShape *RAPIER_CALL r2TrimeshSharedShape(struct R2VectorView vertices,
                                         struct R2TriangleView indices);

RAPIER_API
R2SharedShape *RAPIER_CALL r2PolylineSharedShape(struct R2VectorView vertices,
                                          struct R2EdgeView indices);
 
#if defined(RAPIER_DIM2)
RAPIER_API
R2SharedShape *RAPIER_CALL r2OrientedPolylineSharedShape(struct R2VectorView vertices,
                                                   struct R2EdgeView indices);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API R2SharedShape *RAPIER_CALL r2ConvexPolylineSharedShape(struct R2VectorView vertices);
#endif

RAPIER_API
R2SharedShape *RAPIER_CALL r2RoundConvexHullSharedShape(struct R2VectorView vertices,
                                                   R2Real border_radius);

RAPIER_API
R2SharedShape *RAPIER_CALL r2TrimeshSharedShapeWithFlags(struct R2VectorView vertices,
                                                    struct R2TriangleView indices,
                                                    uint32_t flags);

RAPIER_API struct R2World *RAPIER_CALL r2NewWorld(void);

RAPIER_API R2Status RAPIER_CALL r2FreeWorld(struct R2World *world);

RAPIER_API
struct R2VelocityCorrection RAPIER_CALL r2ReadPidController_RigidBodyCorrection(const struct R2ReadContext *context,
                                                                           struct R2PidController *controller,
                                                                           R2Real dt,
                                                                           struct R2RigidBodyHandle body,
                                                                           struct R2Pose target_pose,
                                                                           struct R2Vector target_linvel,
                                                                           R2AngVector target_angvel);

RAPIER_API
struct R2VelocityCorrection RAPIER_CALL r2ReadPdController_RigidBodyCorrection(const struct R2ReadContext *context,
                                                                          const struct R2PdController *controller,
                                                                          struct R2RigidBodyHandle body,
                                                                          struct R2Pose target_pose,
                                                                          struct R2Vector target_linvel,
                                                                          R2AngVector target_angvel);

RAPIER_API size_t RAPIER_CALL r2ReadRigidBodyCount(const struct R2ReadContext *context);

RAPIER_API
size_t RAPIER_CALL r2ReadRigidBodyHandles(const struct R2ReadContext *context,
                                   struct R2RigidBodyHandle *buffer,
                                   size_t capacity);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_Contains(const struct R2ReadContext *context,
                                     struct R2RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r2ReadColliderCount(const struct R2ReadContext *context);

RAPIER_API
size_t RAPIER_CALL r2ReadColliderHandles(const struct R2ReadContext *context,
                                 struct R2ColliderHandle *buffer,
                                 size_t capacity);

RAPIER_API
R2Bool RAPIER_CALL r2ReadCollider_Contains(const struct R2ReadContext *context,
                                   struct R2ColliderHandle handle);

RAPIER_API
size_t RAPIER_CALL r2ReadCollider_ShapeIdentity(const struct R2ReadContext *context,
                                        struct R2ColliderHandle handle);

RAPIER_API
struct R2MassProperties RAPIER_CALL r2ReadCollider_MassProperties(const struct R2ReadContext *context,
                                                           struct R2ColliderHandle handle);

RAPIER_API
uint8_t RAPIER_CALL r2ReadRigidBody_LockedAxes(const struct R2ReadContext *context,
                                        struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadCollider_IsVoxels(const struct R2ReadContext *context,
                                    struct R2ColliderHandle handle);

RAPIER_API
struct R2VoxelQuery RAPIER_CALL r2ReadCollider_VoxelAtFlatId(const struct R2ReadContext *context,
                                                        struct R2ColliderHandle handle,
                                                        uint32_t id);

RAPIER_API
struct R2Pose RAPIER_CALL r2ReadRigidBody_NextPosition(const struct R2ReadContext *context,
                                                 struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Rotation RAPIER_CALL r2ReadRigidBody_Rotation(const struct R2ReadContext *context,
                                                struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_CenterOfMass(const struct R2ReadContext *context,
                                                    struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_LocalCenterOfMass(const struct R2ReadContext *context,
                                                          struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_UserForce(const struct R2ReadContext *context,
                                                struct R2RigidBodyHandle handle);

RAPIER_API
R2AngVector RAPIER_CALL r2ReadRigidBody_UserTorque(const struct R2ReadContext *context,
                                             struct R2RigidBodyHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r2ReadRigidBody_BodyType(const struct R2ReadContext *context,
                                       struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_Mass(const struct R2ReadContext *context,
                                 struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_GravityScale(const struct R2ReadContext *context,
                                          struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_LinearDamping(const struct R2ReadContext *context,
                                           struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_AngularDamping(const struct R2ReadContext *context,
                                            struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_KineticEnergy(const struct R2ReadContext *context,
                                           struct R2RigidBodyHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadRigidBody_SoftCcdPrediction(const struct R2ReadContext *context,
                                                struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsCcdEnabled(const struct R2ReadContext *context,
                                           struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsDynamic(const struct R2ReadContext *context,
                                       struct R2RigidBodyHandle handle);

RAPIER_API
struct R2SoftBodyHandle RAPIER_CALL r2ReadRigidBody_SoftBody(const struct R2ReadContext *context,
                                                       struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsSoftFrame(const struct R2ReadContext *context,
                                          struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsFixed(const struct R2ReadContext *context,
                                     struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsKinematic(const struct R2ReadContext *context,
                                         struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsMoving(const struct R2ReadContext *context,
                                      struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsCcdActive(const struct R2ReadContext *context,
                                          struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_VelocityAtPoint(const struct R2ReadContext *context,
                                                       struct R2RigidBodyHandle handle,
                                                       struct R2Vector point);

RAPIER_API
size_t RAPIER_CALL r2ReadRigidBody_Colliders(const struct R2ReadContext *context,
                                     struct R2RigidBodyHandle handle,
                                     struct R2ColliderHandle *buffer,
                                     size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_GyroscopicForcesEnabled(const struct R2ReadContext *context,
                                                      struct R2RigidBodyHandle handle);
#endif

RAPIER_API
struct R2Rotation RAPIER_CALL r2ReadCollider_Rotation(const struct R2ReadContext *context,
                                              struct R2ColliderHandle handle);

RAPIER_API
struct R2InteractionGroups RAPIER_CALL r2ReadCollider_CollisionGroups(const struct R2ReadContext *context,
                                                               struct R2ColliderHandle handle);

RAPIER_API
struct R2InteractionGroups RAPIER_CALL r2ReadCollider_SolverGroups(const struct R2ReadContext *context,
                                                            struct R2ColliderHandle handle);

RAPIER_API
struct R2UserData RAPIER_CALL r2ReadCollider_UserData(const struct R2ReadContext *context,
                                               struct R2ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r2ReadCollider_ActiveEvents(const struct R2ReadContext *context,
                                         struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_Mass(const struct R2ReadContext *context,
                               struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_Density(const struct R2ReadContext *context,
                                  struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_Volume(const struct R2ReadContext *context,
                                 struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_ContactSkin(const struct R2ReadContext *context,
                                       struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_ContactForceEventThreshold(const struct R2ReadContext *context,
                                                        struct R2ColliderHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadCollider_IsEnabled(const struct R2ReadContext *context,
                                     struct R2ColliderHandle handle);

RAPIER_API
struct R2Aabb RAPIER_CALL r2ReadCollider_ComputeAabb(const struct R2ReadContext *context,
                                              struct R2ColliderHandle handle);

RAPIER_API
R2SharedShape *RAPIER_CALL r2ReadCollider_CloneShape(const struct R2ReadContext *context,
                                              struct R2ColliderHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2ReadRigidBody_ValidateHandle(const struct R2ReadContext *context,
                                              struct R2RigidBodyHandle handle);

RAPIER_API
R2Status RAPIER_CALL r2ReadCollider_ValidateHandle(const struct R2ReadContext *context,
                                            struct R2ColliderHandle handle);

RAPIER_API
struct R2Pose RAPIER_CALL r2ReadRigidBody_Position(const struct R2ReadContext *context,
                                            struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_Translation(const struct R2ReadContext *context,
                                                 struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadRigidBody_Linvel(const struct R2ReadContext *context,
                                            struct R2RigidBodyHandle handle);

RAPIER_API
R2AngVector RAPIER_CALL r2ReadRigidBody_Angvel(const struct R2ReadContext *context,
                                        struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsSleeping(const struct R2ReadContext *context,
                                        struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsEnabled(const struct R2ReadContext *context,
                                       struct R2RigidBodyHandle handle);

RAPIER_API
struct R2UserData RAPIER_CALL r2ReadRigidBody_UserData(const struct R2ReadContext *context,
                                                 struct R2RigidBodyHandle handle);

RAPIER_API
struct R2Pose RAPIER_CALL r2ReadCollider_Position(const struct R2ReadContext *context,
                                          struct R2ColliderHandle handle);

RAPIER_API
struct R2Vector RAPIER_CALL r2ReadCollider_Translation(const struct R2ReadContext *context,
                                               struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_Friction(const struct R2ReadContext *context,
                                   struct R2ColliderHandle handle);

RAPIER_API
R2Real RAPIER_CALL r2ReadCollider_Restitution(const struct R2ReadContext *context,
                                      struct R2ColliderHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadCollider_IsSensor(const struct R2ReadContext *context,
                                    struct R2ColliderHandle handle);

RAPIER_API
struct R2RigidBodyHandle RAPIER_CALL r2ReadCollider_Parent(const struct R2ReadContext *context,
                                                   struct R2ColliderHandle handle);

RAPIER_API
size_t RAPIER_CALL r2ReadRigidBodyReadStates(const struct R2ReadContext *context,
                                       const struct R2RigidBodyHandle *handles,
                                       size_t handle_count,
                                       struct R2RigidBodyState *states,
                                       size_t capacity);

RAPIER_API
uint16_t RAPIER_CALL r2ReadCollider_ActiveCollisionTypes(const struct R2ReadContext *context,
                                                  struct R2ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r2ReadCollider_ActiveHooks(const struct R2ReadContext *context,
                                        struct R2ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r2ReadCollider_FrictionCombineRule(const struct R2ReadContext *context,
                                                 struct R2ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r2ReadCollider_RestitutionCombineRule(const struct R2ReadContext *context,
                                                    struct R2ColliderHandle handle);

RAPIER_API
struct R2Pose RAPIER_CALL r2ReadCollider_PositionWrtParent(const struct R2ReadContext *context,
                                                     struct R2ColliderHandle handle);

RAPIER_API
int8_t RAPIER_CALL r2ReadRigidBody_DominanceGroup(const struct R2ReadContext *context,
                                           struct R2RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r2ReadRigidBody_AdditionalSolverIterations(const struct R2ReadContext *context,
                                                        struct R2RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r2ReadRigidBody_AdditionalPgsIterations(const struct R2ReadContext *context,
                                                     struct R2RigidBodyHandle handle);

RAPIER_API
R2Bool RAPIER_CALL r2ReadRigidBody_IsFastRotationAllowed(const struct R2ReadContext *context,
                                                     struct R2RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r2IntersectRay(const struct R2World *world,
                         const struct R2QueryOptions *query_options,
                         struct R2Vector origin,
                         struct R2Vector direction,
                         R2Real max_toi,
                         R2Bool solid,
                         struct R2RayHit *buffer,
                         size_t capacity);

RAPIER_API
struct R2OptionalShapeCastHit RAPIER_CALL r2TryCastShape(const struct R2World *world,
                                                  const struct R2QueryOptions *query_options,
                                                  struct R2Pose pose,
                                                  struct R2Vector velocity,
                                                  const R2SharedShape *shape,
                                                  struct R2ShapeCastOptions options);

RAPIER_API
struct R2OptionalPointProjection RAPIER_CALL r2TryProjectPoint(const struct R2World *world,
                                                        const struct R2QueryOptions *query_options,
                                                        struct R2Vector point,
                                                        R2Real max_distance,
                                                        R2Bool solid);

RAPIER_API
struct R2Pose RAPIER_CALL r2NonlinearRigidMotion_PositionAtTime(const struct R2NonlinearRigidMotion *motion,
                                                           R2Real time);

RAPIER_API
struct R2OptionalShapeCastHit RAPIER_CALL r2TryCastShapeNonlinear(const struct R2World *world,
                                                            const struct R2QueryOptions *query_options,
                                                            const struct R2NonlinearRigidMotion *motion,
                                                            const R2SharedShape *shape,
                                                            R2Real start_time,
                                                            R2Real end_time,
                                                            R2Bool stop_at_penetration);

RAPIER_API
struct R2OptionalContactPair RAPIER_CALL r2TryContactPair(struct R2ColliderHandle collider1,
                                                   struct R2ColliderHandle collider2);

RAPIER_API
struct R2IntersectionPair RAPIER_CALL r2IntersectionPair(struct R2ColliderHandle collider1,
                                                 struct R2ColliderHandle collider2);

RAPIER_API
struct R2OptionalIntersectionPair RAPIER_CALL r2TryIntersectionPair(struct R2ColliderHandle collider1,
                                                             struct R2ColliderHandle collider2);

RAPIER_API
size_t RAPIER_CALL r2Collider_ContactPairs(struct R2ColliderHandle handle,
                                  struct R2ContactPair *buffer,
                                  size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2Collider_IntersectionPairs(struct R2ColliderHandle handle,
                                       struct R2IntersectionPair *buffer,
                                       size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2ContactManifolds(struct R2ColliderHandle collider1,
                             struct R2ColliderHandle collider2,
                             struct R2ContactManifold *buffer,
                             size_t capacity);

RAPIER_API
size_t RAPIER_CALL r2SolverContacts(struct R2ColliderHandle collider1,
                           struct R2ColliderHandle collider2,
                           size_t manifold_index,
                           struct R2SolverContact *buffer,
                           size_t capacity);

RAPIER_API
R2Bool RAPIER_CALL r2ContactModificationContext_IsSoft(const struct R2ContactModificationContext *context);

RAPIER_API
size_t RAPIER_CALL r2ContactModificationContext_SolverContactCount(const struct R2ContactModificationContext *context);

RAPIER_API
struct R2SolverContact RAPIER_CALL r2ContactModificationContext_SolverContact(const struct R2ContactModificationContext *context,
                                                                        size_t index);

RAPIER_API
R2Status RAPIER_CALL r2ContactModificationContext_SetSolverContact(struct R2ContactModificationContext *context,
                                                              size_t index,
                                                              const struct R2SolverContact *contact);

RAPIER_API
R2Status RAPIER_CALL r2ContactModificationContext_RemoveSolverContact(struct R2ContactModificationContext *context,
                                                                 size_t index);

RAPIER_API
R2Status RAPIER_CALL r2EventCollector_SetCallbacks(struct R2EventCollector *events,
                                            const struct R2EventCallbacks *callbacks);

RAPIER_API struct R2DebugRenderStyle RAPIER_CALL r2DefaultDebugRenderStyle(void);

RAPIER_API
size_t RAPIER_CALL r2DebugRenderWithStyle(const struct R2World *world,
                                   uint32_t mode,
                                   const struct R2DebugRenderStyle *style,
                                   struct R2DebugLine *buffer,
                                   size_t capacity);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#else /* RAPIER_DIM3 */
 
#if defined(RAPIER_DIM3)
#define R3_FRICTION_MODEL_SIMPLIFIED 0
#endif
 
#if defined(RAPIER_DIM3)
#define R3_FRICTION_MODEL_COULOMB 1
#endif
 
#if defined(RAPIER_DIM2)
#define R3_JOINT_DOF_COUNT 3
#endif
 
#if defined(RAPIER_DIM3)
#define R3_JOINT_DOF_COUNT 6
#endif

#define R3_SOFT_DESC_PARTICLES 0

#define R3_SOFT_DESC_ROPE 1

#define R3_SOFT_DESC_GRID 2

#define R3_SOFT_DESC_CLOTH 3

#define R3_SOFT_DESC_CUBOID 4

#define R3_SOFT_DESC_SURFACE 5

#define R3_SOFT_DESC_DISK 6

#define R3_SOFT_DESC_SPHERE 7

#define R3_SOFT_DESC_CLOTH_TUBE 8

#define R3_SOFT_DESC_VOLUMETRIC 9
 
#if defined(RAPIER_DIM2)
#define R3_SOFT_DESC_POLYGON 10
#endif
 
#if defined(RAPIER_DIM2)
#define R3_SOFT_DESC_TRIMESH 11
#endif
 
#if defined(RAPIER_DIM3)
#define R3_SOFT_DESC_CLOTH_ANISOTROPIC 12
#endif

#define R3_SOFT_BINDING_SKINNED 0

#define R3_SOFT_BINDING_DIRECT 1

#define R3_SOFT_BINDING_DIRECT_BY_POSITION 2
 
#if defined(RAPIER_DIM2)
#define R3_POLYLINE_ORIENTED 1
#endif

#define R3_POLYLINE_DEFORMABLE 2

#define R3_SHAPE_DESC_BALL 0

#define R3_SHAPE_DESC_CUBOID 1

#define R3_SHAPE_DESC_ROUND_CUBOID 2

#define R3_SHAPE_DESC_CAPSULE 3

#define R3_SHAPE_DESC_SEGMENT 4

#define R3_SHAPE_DESC_TRIANGLE 5

#define R3_SHAPE_DESC_HALFSPACE 6

#define R3_SHAPE_DESC_CONVEX_HULL 7

#define R3_SHAPE_DESC_TRIMESH 8

#define R3_SHAPE_DESC_POLYLINE 9

#define R3_SHAPE_DESC_SHARED 10

#define R3_SHAPE_DESC_HEIGHTFIELD 11

#define R3_SHAPE_DESC_CYLINDER 12

#define R3_SHAPE_DESC_CONE 13

#define R3_SHAPE_DESC_COMPOUND 14

#define R3_SHAPE_DESC_ROUND_CYLINDER 15

#define R3_SHAPE_DESC_ROUND_CONE 16

#define R3_MASS_DENSITY 0

#define R3_MASS_TOTAL 1

#define R3_MASS_PROPERTIES 2

#define R3_ABI_VERSION 1

#define R3_DYNAMIC 0

#define R3_FIXED 1

#define R3_KINEMATIC_POSITION_BASED 2

#define R3_KINEMATIC_VELOCITY_BASED 3

#define R3_COLLISION_EVENTS 1

#define R3_CONTACT_FORCE_EVENTS 2

#define R3_COMBINE_AVERAGE 0

#define R3_COMBINE_MIN 1

#define R3_COMBINE_MULTIPLY 2

#define R3_COMBINE_MAX 3

#define R3_COMBINE_CLAMPED_SUM 4

#define R3_COMBINE_GEOMETRIC_MEAN 5

#define R3_COLLISION_TYPES_DYNAMIC_DYNAMIC 1

#define R3_COLLISION_TYPES_DYNAMIC_KINEMATIC 12

#define R3_COLLISION_TYPES_DYNAMIC_FIXED 2

#define R3_COLLISION_TYPES_KINEMATIC_KINEMATIC 52224

#define R3_COLLISION_TYPES_KINEMATIC_FIXED 8704

#define R3_COLLISION_TYPES_FIXED_FIXED 32

#define R3_COLLISION_TYPES_DEFAULT 15

#define R3_FILTER_CONTACT_PAIRS 1

#define R3_FILTER_INTERSECTION_PAIR 2

#define R3_MODIFY_SOLVER_CONTACTS 4

#define R3_QUERY_EXCLUDE_FIXED 1

#define R3_QUERY_EXCLUDE_KINEMATIC 2

#define R3_QUERY_EXCLUDE_DYNAMIC 4

#define R3_QUERY_EXCLUDE_SENSORS 8

#define R3_QUERY_EXCLUDE_SOLIDS 16

#define R3_QUERY_ONLY_DYNAMIC 3

#define R3_QUERY_ONLY_KINEMATIC 5

#define R3_QUERY_ONLY_FIXED 6

#define R3_DEBUG_COLLIDER_SHAPES 1

#define R3_DEBUG_RIGID_BODY_AXES 2

#define R3_DEBUG_MULTIBODY_JOINTS 4

#define R3_DEBUG_IMPULSE_JOINTS 8

#define R3_DEBUG_SOLVER_CONTACTS 16

#define R3_DEBUG_CONTACTS 32

#define R3_DEBUG_COLLIDER_AABBS 64

#define R3_DEBUG_SOFT_BODIES 128

#define R3_DEBUG_PSEUDO_NORMALS 256

#define R3_DEBUG_SOFT_VOLUME_CONTACTS 512

#define R3_DEBUG_SOFT_BODY_STRESS 1024

#define R3_GROUPS_AND 0

#define R3_GROUPS_OR 1

#define R3_MOTOR_ACCELERATION_BASED 0

#define R3_MOTOR_FORCE_BASED 1

#define R3_SOFT_CELL_VOLUME 0

#define R3_SOFT_CELL_COROTATIONAL 1

#define R3_SOFT_CELL_NEO_HOOKEAN 2

#define R3_SOFT_SOLVER_CONSTRAINTS 0

#define R3_SOFT_SOLVER_FEM 1

#define R3_SOFT_EDGE_PLASTIC_FLOW_BOTH 0

#define R3_SOFT_EDGE_PLASTIC_FLOW_COMPRESSION 1

#define R3_SOFT_EDGE_PLASTIC_FLOW_TENSION 2

#define R3_SOFT_PATCH_CONSTRAINTS_KEEP 0

#define R3_SOFT_PATCH_CONSTRAINTS_STAND_DOWN 1

#define R3_SOFT_PATCH_CONSTRAINTS_ALONG_NORMAL 2

#define R3_AXIS_LIN_X 0

#define R3_AXIS_LIN_Y 1

#define R3_LOCK_TRANSLATION_X 1

#define R3_LOCK_TRANSLATION_Y 2

#define R3_LOCK_TRANSLATION_Z 4

#define R3_LOCK_ROTATION_X 8

#define R3_LOCK_ROTATION_Y 16

#define R3_LOCK_ROTATION_Z 32
 
#if defined(RAPIER_DIM2)
#define R3_AXIS_ANG_X 2
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXIS_ANG_X 3
#endif
 
#if defined(RAPIER_DIM2)
#define R3_JOINT_FIXED_AXES 7
#endif
 
#if defined(RAPIER_DIM3)
#define R3_JOINT_FIXED_AXES 63
#endif
 
#if defined(RAPIER_DIM2)
#define R3_JOINT_REVOLUTE_AXES 3
#endif
 
#if defined(RAPIER_DIM3)
#define R3_JOINT_REVOLUTE_AXES 55
#endif
 
#if defined(RAPIER_DIM2)
#define R3_JOINT_PRISMATIC_AXES 6
#endif
 
#if defined(RAPIER_DIM3)
#define R3_JOINT_PRISMATIC_AXES 62
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXIS_LIN_Z 2
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXIS_ANG_Y 4
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXIS_ANG_Z 5
#endif
 
#if defined(RAPIER_DIM3)
#define R3_JOINT_SPHERICAL_AXES 7
#endif

#define R3_SOFT_FRAME 4

#define R3_SHAPE_CAST_OUT_OF_ITERATIONS 0

#define R3_SHAPE_CAST_CONVERGED 1

#define R3_SHAPE_CAST_FAILED 2

#define R3_SHAPE_CAST_PENETRATING 3

#define R3_FEATURE_UNKNOWN 0

#define R3_FEATURE_VERTEX 1

#define R3_FEATURE_EDGE 2

#define R3_FEATURE_FACE 3

#define R3_MULTIBODY_JOINTS_ARE_KINEMATIC 1

#define R3_MULTIBODY_DISABLE_SELF_CONTACTS 2

#define R3_MULTIBODY_SKIP_LOOP_CLOSURES 4

#define R3_MULTIBODY_SKIP_JOINT_MOTORS 8

#define R3_MULTIBODY_SKIP_JOINT_LIMITS 16

#define R3_MULTIBODY_SKIP_JOINT_SPRINGS 32

#define R3_TRIMESH_HALF_EDGE_TOPOLOGY 1

#define R3_TRIMESH_CONNECTED_COMPONENTS 2

#define R3_TRIMESH_DELETE_BAD_TOPOLOGY_TRIANGLES 4

#define R3_TRIMESH_ORIENTED 8

#define R3_TRIMESH_MERGE_DUPLICATE_VERTICES 16

#define R3_TRIMESH_DELETE_DEGENERATE_TRIANGLES 32

#define R3_TRIMESH_DELETE_DUPLICATE_TRIANGLES 64

#define R3_TRIMESH_FIX_INTERNAL_EDGES 144

#define R3_TRIMESH_DEFORMABLE 256

#define R3_TRIMESH_FIX_INTERNAL_EDGES_TWO_SIDED 656

#define R3_HEIGHTFIELD_FIX_INTERNAL_EDGES 1

#define R3_AXES_MASK_LIN_X 1

#define R3_AXES_MASK_LIN_Y 2
 
#if defined(RAPIER_DIM3)
#define R3_AXES_MASK_LIN_Z 4
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXES_MASK_ANG_X 8
#endif
 
#if defined(RAPIER_DIM3)
#define R3_AXES_MASK_ANG_Y 16
#endif

#define R3_AXES_MASK_ANG_Z 32

#define R3_ABI_FEATURE_FEM 1

#define R3_ABI_FEATURE_ROBOTICS 2
 
#if (defined(RAPIER_FEM) && defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_ABI_FEATURES 3
#endif
 
#if (defined(RAPIER_FEM) && !(defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32)))
#define R3_ABI_FEATURES 1
#endif
 
#if (!defined(RAPIER_FEM) && defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_ABI_FEATURES 2
#endif
 
#if (!defined(RAPIER_FEM) && !(defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32)))
#define R3_ABI_FEATURES 0
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_MESH_CONVERTER_TRIMESH 0
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_MESH_CONVERTER_OBB 1
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_MESH_CONVERTER_AABB 2
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_MESH_CONVERTER_CONVEX_HULL 3
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
#define R3_MESH_CONVERTER_CONVEX_DECOMPOSITION 4
#endif

#define R3_COLLISION_EVENT_SENSOR 1

#define R3_COLLISION_EVENT_REMOVED 2

typedef struct R3Bytes R3Bytes;

typedef struct R3ContactModificationContext R3ContactModificationContext;
 
#if defined(RAPIER_DIM3)
typedef struct R3DynamicRayCastVehicleController R3DynamicRayCastVehicleController;
#endif

typedef struct R3EventCollector R3EventCollector;

typedef struct R3KinematicCharacterController R3KinematicCharacterController;
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3LoadedMeshes R3LoadedMeshes;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfContactHooks R3MjcfContactHooks;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfRobot R3MjcfRobot;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfRobotHandles R3MjcfRobotHandles;
#endif

typedef struct R3PidController R3PidController;

typedef struct R3ReadContext R3ReadContext;

typedef struct R3ShapeMesh R3ShapeMesh;

typedef struct R3SoftBodyTearEvent R3SoftBodyTearEvent;
 
#if defined(RAPIER_DIM3)
typedef struct R3TriMeshData R3TriMeshData;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3UrdfRobot R3UrdfRobot;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3UrdfRobotHandles R3UrdfRobotHandles;
#endif

typedef struct R3World R3World;
 
#if defined(RAPIER_F32)
typedef float R3Real;
#endif
 
#if defined(RAPIER_F64)
typedef double R3Real;
#endif

typedef struct R3SpringCoefficients {
  R3Real natural_frequency;
  R3Real damping_ratio;
} R3SpringCoefficients;

typedef uint32_t R3Bool;

typedef struct R3OptionalReal {
  R3Bool enabled;
  R3Real value;
} R3OptionalReal;

typedef struct R3OptionalU32 {
  R3Bool enabled;
  uint32_t value;
} R3OptionalU32;

typedef struct R3SoftBodyMaterial {
  struct R3SpringCoefficients edgeSoftness;
  struct R3SpringCoefficients bendSoftness;
  struct R3SpringCoefficients volumeSoftness;
  struct R3SpringCoefficients shapeMatchingSoftness;
  R3Real youngModulus;
  R3Real poissonRatio;
  R3Real elasticDampingRatio;
  R3Real plasticYield;
  R3Real plasticCreep;
  R3Real plasticMax;
  R3Real deformationDamping;
  R3Real edgePlasticYield;
  R3Real edgePlasticCreep;
  R3Real edgePlasticMax;
  uint32_t edgePlasticFlow;
  struct R3OptionalReal tearStrain;
  struct R3OptionalReal tearForce;
  R3Real tearSmoothing;
  R3Real interiorStrength;
  uint32_t maxTearsPerStep;
  struct R3OptionalU32 minPiece;
} R3SoftBodyMaterial;

typedef struct R3SoftRecoverySettings {
  R3Bool authoredVelocityMargin;
  R3Bool edgeSpeculation;
  R3Bool invertedCellDetection;
  R3Bool selfCrossingDetection;
  R3Bool detectionMotionGating;
  R3Bool crossBodyDetection;
  R3Bool selfStandDown;
  R3Bool crossBodyExpelGate;
  R3Bool edgeStandDown;
  R3Bool crossingRepulsion;
  R3Bool crossingRepulsionGuide;
  R3Bool crossingRepulsionSelfGuide;
  R3Real recoveryPace;
  R3Bool overlapConstraints;
  R3Bool overlapRigid;
  R3Bool overlapSkipSelfTangled;
  R3Bool overlapEdgeStandDown;
  R3Real overlapConstraintPace;
  uint32_t overlapPatchConstraints;
  R3Bool overlapSkinVolume;
  R3Real overlapKeptDepth;
  R3Bool overlapSelfRegions;
  R3Bool overlapNormalPush;
  R3Bool overlapMultiVolume;
  uint32_t overlapSplit;
  uint32_t overlapPatience;
  R3Real overlapProgressMargin;
} R3SoftRecoverySettings;
 
#if defined(RAPIER_FEM)
typedef struct R3SoftFemParameters {
  R3Real linearTolerance;
  size_t maxLinearIterations;
  size_t maxDenseDofs;
} R3SoftFemParameters;
#endif

typedef struct R3SoftBodiesSettings {
  struct R3SoftRecoverySettings recovery;
  R3Real resweepStrain;
  size_t maxExtraSubsteps;
  R3Real contactStiffening;
#if defined(RAPIER_FEM)
  struct R3SoftFemParameters fem;
#endif
} R3SoftBodiesSettings;

typedef struct R3IntegrationParameters {
  R3Real dt;
  R3Real minCcdDt;
  struct R3SpringCoefficients contactSoftness;
  struct R3SpringCoefficients staticContactSoftness;
  R3Real warmstartCoefficient;
  R3Real lengthUnit;
  struct R3SoftBodiesSettings softBodies;
  R3Real normalizedAllowedLinearError;
  R3Real normalizedMaxCorrectiveVelocity;
  R3Real normalizedPredictionDistance;
  R3Real normalizedMaxLinearVelocity;
  size_t numSolverIterations;
  size_t numInternalPgsIterations;
  size_t numInternalStabilizationIterations;
  size_t maxCcdSubsteps;
  R3Bool contactClustering;
  R3Bool contactRecycling;
  R3Real normalizedContactRecycleDistance;
  R3Bool frictionInBiasPass;
  R3Bool warmstartJoints;
#if defined(RAPIER_DIM3)
  uint32_t frictionModel;
#endif
} R3IntegrationParameters;

typedef uint32_t R3Status;

typedef struct R3Vector {
  R3Real x;
  R3Real y;
#if defined(RAPIER_DIM3)
  R3Real z;
#endif
} R3Vector;

typedef struct R3Rotation {
#if defined(RAPIER_DIM2)
  R3Real angle;
#endif
#if defined(RAPIER_DIM3)
  R3Real x;
#endif
#if defined(RAPIER_DIM3)
  R3Real y;
#endif
#if defined(RAPIER_DIM3)
  R3Real z;
#endif
#if defined(RAPIER_DIM3)
  R3Real w;
#endif
} R3Rotation;

typedef struct R3Pose {
  struct R3Vector translation;
  struct R3Rotation rotation;
} R3Pose;

typedef struct R3JointLimits {
  R3Real min;
  R3Real max;
} R3JointLimits;

typedef struct R3JointMotor {
  R3Real targetVel;
  R3Real targetPos;
  R3Real stiffness;
  R3Real damping;
  R3Real maxForce;
  uint32_t model;
} R3JointMotor;

typedef struct R3UserData {
  uint64_t low;
  uint64_t high;
} R3UserData;

typedef struct R3JointDesc {
  struct R3Pose localFrame1;
  struct R3Pose localFrame2;
  uint8_t lockedAxes;
  uint8_t limitAxes;
  uint8_t motorAxes;
  uint8_t coupledAxes;
  struct R3JointLimits limits[R3_JOINT_DOF_COUNT];
  struct R3JointMotor motors[R3_JOINT_DOF_COUNT];
  struct R3SpringCoefficients softness;
  R3Bool contactsEnabled;
  R3Bool enabled;
  struct R3UserData userData;
} R3JointDesc;

typedef struct R3ImpulseJointHandle {
  struct R3World *world;
  uint32_t index;
  uint32_t generation;
} R3ImpulseJointHandle;

typedef struct R3RigidBodyHandle {
  struct R3World *world;
  uint32_t index;
  uint32_t generation;
} R3RigidBodyHandle;

typedef struct R3MultibodyJointHandle {
  struct R3World *world;
  uint32_t index;
  uint32_t generation;
} R3MultibodyJointHandle;

typedef struct R3VolumeMeshParameters {
  R3Real cell_size;
#if defined(RAPIER_DIM2)
  R3Real min_angle;
#endif
#if defined(RAPIER_DIM3)
  uint32_t enclosure;
#endif
#if defined(RAPIER_DIM3)
  uint32_t cover_smoothing;
#endif
#if defined(RAPIER_DIM3)
  R3Real cover_guard;
#endif
#if defined(RAPIER_DIM3)
  uint32_t cover_subdivisions;
#endif
} R3VolumeMeshParameters;

typedef struct R3VectorView {
  const struct R3Vector *data;
  size_t count;
} R3VectorView;

typedef struct R3RealView {
  const R3Real *data;
  size_t count;
} R3RealView;

typedef struct R3IndexView {
  const uint32_t *data;
  size_t count;
} R3IndexView;

typedef struct R3Edge {
  uint32_t a;
  uint32_t b;
} R3Edge;

typedef struct R3EdgeView {
  const struct R3Edge *data;
  size_t count;
} R3EdgeView;

typedef struct R3SoftEdgeSoftness {
  uint32_t edge;
  struct R3SpringCoefficients softness;
} R3SoftEdgeSoftness;

typedef struct R3SoftEdgeSoftnessView {
  const struct R3SoftEdgeSoftness *data;
  size_t count;
} R3SoftEdgeSoftnessView;

typedef struct R3SoftEdgeTear {
  uint32_t edge;
  R3Real resistance;
} R3SoftEdgeTear;

typedef struct R3SoftEdgeTearView {
  const struct R3SoftEdgeTear *data;
  size_t count;
} R3SoftEdgeTearView;

typedef struct R3Triangle {
  uint32_t a;
  uint32_t b;
  uint32_t c;
} R3Triangle;

typedef struct R3TriangleView {
  const struct R3Triangle *data;
  size_t count;
} R3TriangleView;

typedef struct R3Tetrahedron {
  uint32_t a;
  uint32_t b;
  uint32_t c;
  uint32_t d;
} R3Tetrahedron;

typedef struct R3TetrahedronView {
  const struct R3Tetrahedron *data;
  size_t count;
} R3TetrahedronView;
 
#if defined(RAPIER_DIM2)
typedef struct R3TriangleView R3CellView;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R3TetrahedronView R3CellView;
#endif
 
#if defined(RAPIER_DIM2)
typedef struct R3EdgeView R3SurfaceElementView;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R3TriangleView R3SurfaceElementView;
#endif

typedef struct R3Dihedral {
  uint32_t a;
  uint32_t b;
  uint32_t c;
  uint32_t d;
} R3Dihedral;

typedef struct R3DihedralView {
  const struct R3Dihedral *data;
  size_t count;
} R3DihedralView;

typedef struct R3SoftBodyDescView {
  const struct R3SoftBodyDesc *data;
  size_t count;
} R3SoftBodyDescView;

typedef struct R3OptionalBool {
  R3Bool enabled;
  R3Bool value;
} R3OptionalBool;

typedef struct R3SharedShape R3SharedShape;
 

typedef struct R3CompoundShapeView {
  const struct R3CompoundShapeDesc *data;
  size_t count;
} R3CompoundShapeView;

typedef struct R3ShapeDesc {
  uint32_t kind;
  struct R3Vector a;
  struct R3Vector b;
  struct R3Vector c;
  R3Real radius;
  R3Real halfHeight;
  R3Real borderRadius;
  struct R3VectorView vertices;
  struct R3TriangleView triangles;
  struct R3EdgeView edges;
  uint32_t flags;
  struct R3RealView heights;
  size_t rows;
  size_t columns;
  struct R3Vector scale;
  const R3SharedShape *sharedShape;
  struct R3CompoundShapeView children;
} R3ShapeDesc;

typedef struct R3CompoundShapeDesc {
  struct R3Pose pose;
  struct R3ShapeDesc shape;
} R3CompoundShapeDesc;
 
 
#if defined(RAPIER_DIM2)
typedef R3Real R3AngVector;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R3Vector R3AngVector;
#endif

typedef struct R3MassProperties {
  struct R3Vector local_com;
  R3Real mass;
  R3AngVector principal_inertia;
#if defined(RAPIER_DIM3)
  struct R3Rotation principal_inertia_local_frame;
#endif
} R3MassProperties;

typedef struct R3InteractionGroups {
  uint32_t memberships;
  uint32_t filter;
  uint32_t test_mode;
} R3InteractionGroups;

typedef struct R3ColliderDesc {
  struct R3ShapeDesc shape;
  struct R3Pose position;
  uint32_t massMode;
  R3Real density;
  R3Real mass;
  struct R3MassProperties massProperties;
  R3Real friction;
  R3Real restitution;
  uint32_t frictionCombineRule;
  uint32_t restitutionCombineRule;
  R3Bool isSensor;
  R3Bool enabled;
  struct R3InteractionGroups collisionGroups;
  struct R3InteractionGroups solverGroups;
  uint16_t activeCollisionTypes;
  uint32_t activeHooks;
  uint32_t activeEvents;
  R3Real contactForceEventThreshold;
  R3Real contactSkin;
  struct R3UserData userData;
} R3ColliderDesc;

typedef struct R3SoftBodyDesc {
  uint32_t kind;
  struct R3Vector a;
  struct R3Vector b;
  struct R3Vector du;
  struct R3Vector dv;
#if defined(RAPIER_DIM3)
  struct R3SpringCoefficients warpSoftness;
#endif
#if defined(RAPIER_DIM3)
  struct R3SpringCoefficients weftSoftness;
#endif
#if defined(RAPIER_DIM3)
  struct R3SpringCoefficients shearSoftness;
#endif
  size_t nx;
  size_t ny;
  size_t nz;
  R3Real radius;
  R3Real radiusEnd;
  struct R3Vector translation;
  struct R3OptionalReal totalMass;
  struct R3VolumeMeshParameters meshing;
  struct R3VectorView positions;
  struct R3RealView masses;
  struct R3IndexView pinned;
  struct R3EdgeView edges;
  struct R3EdgeView bendEdges;
  struct R3IndexView tensionOnlyEdges;
  struct R3SoftEdgeSoftnessView edgeSoftness;
  struct R3SoftEdgeTearView edgeTearResistance;
  R3CellView cells;
  R3SurfaceElementView surface;
#if defined(RAPIER_DIM3)
  struct R3DihedralView dihedrals;
#endif
#if defined(RAPIER_DIM3)
  struct R3EdgeView wire;
#endif
  struct R3VectorView skinVertices;
  R3SurfaceElementView skinIndices;
  struct R3SoftBodyDescView appended;
  struct R3EdgeView addedEdges;
  struct R3SoftBodyMaterial material;
  uint32_t cellModel;
  uint32_t solver;
  R3Real particleMass;
  struct R3OptionalReal particleRadius;
  R3Bool volumePreservation;
  R3Real volumeFactor;
  struct R3OptionalBool shapeMatching;
  struct R3OptionalBool oriented;
  R3Bool selfContacts;
  R3Bool skinCollision;
  R3Bool collisionEnabled;
  struct R3ColliderDesc collider;
  R3Real linearDamping;
  R3Real gravityScale;
  size_t additionalSolverIterations;
  size_t additionalPgsIterations;
  R3Bool canSleep;
  int8_t dominanceGroup;
  struct R3UserData userData;
} R3SoftBodyDesc;

typedef struct R3SoftBodyHandle {
  struct R3World *world;
  uint32_t index;
  uint32_t generation;
} R3SoftBodyHandle;

typedef struct R3SoftMeshBindingDesc {
  uint32_t kind;
  struct R3IndexView particles;
  R3Real epsilon;
  R3Bool selfContacts;
} R3SoftMeshBindingDesc;

typedef struct R3ColliderHandle {
  struct R3World *world;
  uint32_t index;
  uint32_t generation;
} R3ColliderHandle;

typedef struct R3QueryFilter {
  uint32_t flags;
  R3Bool use_groups;
  struct R3InteractionGroups groups;
  struct R3ColliderHandle exclude_collider;
  struct R3RigidBodyHandle exclude_rigid_body;
} R3QueryFilter;

typedef R3Bool (RAPIER_CALL *R3QueryPredicate)(void *user_data,
                                     const struct R3ReadContext *read,
                                     struct R3ColliderHandle handle);

typedef struct R3QueryOptions {
  struct R3QueryFilter filter;
  R3QueryPredicate predicate;
  void *userData;
} R3QueryOptions;

typedef struct R3RayHit {
  struct R3ColliderHandle collider;
  R3Real time_of_impact;
  struct R3Vector normal;
  uint32_t feature_type;
  uint32_t feature_id;
} R3RayHit;

typedef struct R3PointProjection {
  struct R3ColliderHandle collider;
  struct R3Vector point;
  R3Bool is_inside;
} R3PointProjection;

typedef struct R3ShapeCastHit {
  struct R3ColliderHandle collider;
  R3Real time_of_impact;
  struct R3Vector witness1;
  struct R3Vector witness2;
  struct R3Vector normal1;
  struct R3Vector normal2;
  uint32_t status;
} R3ShapeCastHit;

typedef struct R3ShapeCastOptions {
  R3Real max_time_of_impact;
  R3Real target_distance;
  R3Bool stop_at_penetration;
  R3Bool compute_impact_geometry_on_penetration;
} R3ShapeCastOptions;

typedef struct R3Aabb {
  struct R3Vector mins;
  struct R3Vector maxs;
} R3Aabb;

typedef struct R3RayToi {
  struct R3ColliderHandle collider;
  R3Real toi;
  R3Bool found;
} R3RayToi;

typedef struct R3OptionalRayHit {
  struct R3RayHit hit;
  R3Bool found;
} R3OptionalRayHit;

typedef struct R3RigidBodyDesc {
  struct R3Pose position;
  struct R3Vector linvel;
  R3AngVector angvel;
  uint32_t bodyType;
  R3Real gravityScale;
  R3Real linearDamping;
  R3Real angularDamping;
  R3Real additionalMass;
  R3Bool useAdditionalMassProperties;
  struct R3MassProperties additionalMassProperties;
  uint8_t lockedAxes;
  R3Bool canSleep;
  R3Bool sleeping;
  R3Bool ccdEnabled;
  R3Real softCcdPrediction;
  R3Bool allowFastRotation;
  R3Bool enabled;
  int8_t dominanceGroup;
  size_t additionalSolverIterations;
  size_t additionalPgsIterations;
  R3Bool gyroscopicForcesEnabled;
  struct R3UserData userData;
} R3RigidBodyDesc;

typedef struct R3PodLayout {
  size_t rigidBodyDesc;
  size_t colliderDesc;
  size_t shapeDesc;
  size_t jointDesc;
  size_t softBodyMaterial;
  size_t integrationParameters;
  size_t softBodyDesc;
  size_t softMeshBindingDesc;
  size_t queryOptions;
  size_t urdfLoaderOptions;
  size_t mjcfLoaderOptions;
} R3PodLayout;

typedef struct R3CharacterLength {
  R3Real value;
  R3Bool relative;
} R3CharacterLength;

typedef struct R3CharacterAutostep {
  R3Bool enabled;
  struct R3CharacterLength max_height;
  struct R3CharacterLength min_width;
  R3Bool include_dynamic_bodies;
} R3CharacterAutostep;

typedef struct R3CharacterMovement {
  struct R3Vector translation;
  R3Bool grounded;
  R3Bool is_sliding_down_slope;
} R3CharacterMovement;

typedef struct R3CharacterCollision {
  struct R3ColliderHandle collider;
  struct R3Pose character_pos;
  struct R3Vector translation_applied;
  struct R3Vector translation_remaining;
  struct R3ShapeCastHit hit;
} R3CharacterCollision;

typedef struct R3PidGains {
  struct R3Vector lin_kp;
  struct R3Vector lin_ki;
  struct R3Vector lin_kd;
  R3AngVector ang_kp;
  R3AngVector ang_ki;
  R3AngVector ang_kd;
} R3PidGains;

typedef struct R3PdController {
  struct R3Vector lin_kp;
  struct R3Vector lin_kd;
  R3AngVector ang_kp;
  R3AngVector ang_kd;
  uint32_t axes;
} R3PdController;

typedef struct R3VelocityCorrection {
  struct R3Vector linear;
  R3AngVector angularVelocity;
} R3VelocityCorrection;

typedef struct R3CharacterControllerSettings {
  R3Bool slide;
  R3Real max_slope_climb_angle;
  R3Real min_slope_slide_angle;
  R3Bool snap_to_ground;
  struct R3CharacterLength snap_distance;
} R3CharacterControllerSettings;
 
#if defined(RAPIER_DIM3)
typedef struct R3WheelTuning {
  R3Real suspension_stiffness;
  R3Real suspension_compression;
  R3Real suspension_damping;
  R3Real max_suspension_travel;
  R3Real friction_slip;
  R3Real max_suspension_force;
  R3Real side_friction_stiffness;
} R3WheelTuning;
#endif
 
#if defined(RAPIER_DIM3)
typedef struct R3WheelState {
  struct R3Vector center;
  struct R3Vector suspension;
  struct R3Vector axle;
  R3Real rotation;
  R3Real suspension_force;
  R3Real suspension_length;
  R3Bool is_in_contact;
  struct R3ColliderHandle ground_object;
  struct R3Vector contact_point;
  struct R3Vector contact_normal;
} R3WheelState;
#endif

typedef void (RAPIER_CALL *R3ErrorCallback)(R3Status, const char*, void*);

typedef struct R3ErrorHandler {
  R3ErrorCallback callback;
  void *user_data;
} R3ErrorHandler;

typedef struct R3JointBodies {
  struct R3RigidBodyHandle body1;
  struct R3RigidBodyHandle body2;
} R3JointBodies;

typedef struct R3InverseKinematicsOptions {
  R3Real damping;
  size_t max_iters;
  uint8_t constrained_axes;
  R3Real epsilon_linear;
  R3Real epsilon_angular;
} R3InverseKinematicsOptions;

typedef R3Bool (RAPIER_CALL *R3IkJointCanMove)(void*, struct R3RigidBodyHandle);

typedef struct R3CollisionEvent {
  struct R3ColliderHandle collider1;
  struct R3ColliderHandle collider2;
  R3Bool started;
  uint32_t flags;
} R3CollisionEvent;

typedef struct R3ContactForceEvent {
  struct R3ColliderHandle collider1;
  struct R3ColliderHandle collider2;
  struct R3Vector total_force;
  R3Real total_force_magnitude;
  struct R3Vector max_force_direction;
  R3Real max_force_magnitude;
  R3Bool started;
} R3ContactForceEvent;

typedef int32_t (RAPIER_CALL *R3PairFilter)(void *user_data,
                                 const struct R3ReadContext *read,
                                 struct R3ColliderHandle collider1,
                                 struct R3ColliderHandle collider2,
                                 struct R3RigidBodyHandle body1,
                                 struct R3RigidBodyHandle body2);

typedef struct R3ContactModification {
  struct R3Vector normal;
  R3Real friction;
  R3Real restitution;
  uint32_t user_data;
  R3Bool enabled;
} R3ContactModification;

typedef void (RAPIER_CALL *R3ModifyContacts)(void *user_data,
                                  const struct R3ReadContext *read,
                                  struct R3ColliderHandle collider1,
                                  struct R3ColliderHandle collider2,
                                  struct R3ContactModification *contact);

typedef void (RAPIER_CALL *R3ModifyContactContext)(void *user_data,
                                        const struct R3ReadContext *read,
                                        struct R3ColliderHandle collider1,
                                        struct R3ColliderHandle collider2,
                                        struct R3ContactModificationContext *context);

typedef struct R3PhysicsHooks {
  void *user_data;
  R3PairFilter filter_contact_pair;
  R3PairFilter filter_intersection_pair;
  R3ModifyContacts modify_solver_contacts;
  R3ModifyContactContext modify_solver_contacts_context;
} R3PhysicsHooks;

typedef struct R3ByteView {
  const uint8_t *data;
  size_t count;
} R3ByteView;

typedef struct R3DebugLine {
  struct R3Vector a;
  struct R3Vector b;
  float color[4];
} R3DebugLine;

typedef struct R3ParticleDestination {
  struct R3SoftBodyHandle body;
  uint32_t index;
} R3ParticleDestination;

typedef struct R3SoftClusterSplit {
  uint32_t source_cluster;
  struct R3SoftBodyHandle soft_body;
  uint32_t cluster;
  struct R3RigidBodyHandle proxy;
  R3Bool keeps_proxy;
} R3SoftClusterSplit;

typedef struct R3SoftJointMove {
  struct R3ImpulseJointHandle joint;
  struct R3RigidBodyHandle from;
  struct R3RigidBodyHandle to;
} R3SoftJointMove;

typedef struct R3OptionalParticleDestination {
  struct R3SoftBodyHandle body;
  uint32_t index;
  R3Bool found;
} R3OptionalParticleDestination;

typedef struct R3BuildInfo {
  uint32_t abi_version;
  uint32_t dimension;
  uint32_t real_size;
  uint32_t pointer_size;
} R3BuildInfo;

typedef struct R3BuildFeatures {
  R3Bool profiling;
  uint32_t simd_lanes;
  R3Bool parallel;
  R3Bool enhanced_determinism;
} R3BuildFeatures;

typedef struct R3ContactPair {
  struct R3ColliderHandle collider1;
  struct R3ColliderHandle collider2;
  R3Bool has_any_active_contact;
  struct R3Vector total_impulse;
  R3Real total_impulse_magnitude;
  R3Real max_impulse;
  struct R3Vector max_impulse_direction;
} R3ContactPair;

typedef struct R3IntersectionPair {
  struct R3ColliderHandle collider1;
  struct R3ColliderHandle collider2;
  R3Bool intersecting;
} R3IntersectionPair;

typedef struct R3ContactPoint {
  size_t manifold_index;
  struct R3Vector local_p1;
  struct R3Vector local_p2;
  struct R3Vector normal;
  R3Real distance;
  R3Real impulse;
#if defined(RAPIER_DIM2)
  R3Real tangent_impulse[1];
#endif
#if defined(RAPIER_DIM3)
  R3Real tangent_impulse[2];
#endif
} R3ContactPoint;
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3UrdfLoaderOptions {
  R3Bool createCollidersFromCollisionShapes;
  R3Bool createCollidersFromVisualShapes;
  R3Bool applyImportedMassProps;
  R3Bool enableJointCollisions;
  R3Bool makeRootsFixed;
  R3Bool squeezeEmptyFixedLinks;
  struct R3Pose shift;
  R3Real scale;
  struct R3ColliderDesc colliderBlueprint;
  struct R3RigidBodyDesc rigidBodyBlueprint;
} R3UrdfLoaderOptions;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfLoaderOptions {
  R3Bool createCollidersFromCollisionShapes;
  R3Bool createCollidersFromVisualShapes;
  R3Bool applyImportedMassProps;
  R3Bool enableJointCollisions;
  R3Bool makeRootsFixed;
  R3Bool skipPlaneGeoms;
  R3Bool disableJointMotors;
  struct R3Pose shift;
  R3Real scale;
  struct R3ColliderDesc colliderBlueprint;
  struct R3RigidBodyDesc rigidBodyBlueprint;
} R3MjcfLoaderOptions;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfVisualMesh R3MjcfVisualMesh;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3RenderMaterial {
  float metallic;
  float roughness;
  float reflectance;
  float emissive[3];
} R3RenderMaterial;
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
typedef struct R3MjcfVisualMeshInfo {
  struct R3Pose local_pose;
  float rgba[4];
  struct R3RenderMaterial material;
  R3Bool has_color;
  R3Bool has_material;
  R3Bool is_trimesh;
} R3MjcfVisualMeshInfo;
#endif

typedef struct R3RigidBodyState {
  struct R3Pose position;
  struct R3Vector linvel;
  R3AngVector angvel;
  R3Bool sleeping;
  R3Bool enabled;
  struct R3UserData userData;
} R3RigidBodyState;

typedef struct R3SoftMeshId {
  uint32_t cluster;
  uint32_t mesh;
} R3SoftMeshId;

typedef struct R3SoftMeshInfo {
  struct R3SoftMeshId id;
  struct R3ColliderHandle collider;
  size_t arity;
  R3Bool is_skinned;
  R3Bool collision_enabled;
} R3SoftMeshInfo;
 
#if defined(RAPIER_F32)
typedef int32_t R3VoxelCoord;
#endif
 
#if defined(RAPIER_F64)
typedef int64_t R3VoxelCoord;
#endif

typedef struct R3VoxelKey {
  R3VoxelCoord x;
  R3VoxelCoord y;
#if defined(RAPIER_DIM3)
  R3VoxelCoord z;
#endif
} R3VoxelKey;

typedef struct R3VoxelQuery {
  struct R3VoxelKey key;
  struct R3Vector center;
  struct R3Vector size;
  R3Bool found;
} R3VoxelQuery;

typedef struct R3JointImpulses {
  struct R3Vector linear;
  R3AngVector angular;
  R3Real limits[R3_JOINT_DOF_COUNT];
  R3Real motors[R3_JOINT_DOF_COUNT];
} R3JointImpulses;

typedef struct R3OptionalShapeCastHit {
  struct R3ShapeCastHit hit;
  R3Bool found;
} R3OptionalShapeCastHit;

typedef struct R3OptionalPointProjection {
  struct R3PointProjection projection;
  R3Bool found;
} R3OptionalPointProjection;

typedef struct R3NonlinearRigidMotion {
  struct R3Pose start;
  struct R3Vector local_center;
  struct R3Vector linvel;
  R3AngVector angvel;
} R3NonlinearRigidMotion;

typedef struct R3OptionalContactPair {
  struct R3ContactPair pair;
  R3Bool found;
} R3OptionalContactPair;

typedef struct R3OptionalIntersectionPair {
  struct R3IntersectionPair pair;
  R3Bool found;
} R3OptionalIntersectionPair;

typedef struct R3ContactManifold {
  struct R3Vector local_n1;
  struct R3Vector local_n2;
  struct R3Vector normal;
  uint32_t subshape1;
  uint32_t subshape2;
  size_t num_points;
  size_t num_solver_contacts;
  uint32_t user_data;
} R3ContactManifold;

typedef struct R3SolverContact {
  struct R3Vector point1;
  struct R3Vector point2;
  R3Real distance;
  struct R3Vector tangent_velocity;
} R3SolverContact;

typedef void (RAPIER_CALL *R3CollisionEventCallback)(void *user_data,
                                          const struct R3ReadContext *read,
                                          const struct R3CollisionEvent *event,
                                          const struct R3ContactPoint *contacts,
                                          size_t contact_count);

typedef void (RAPIER_CALL *R3ContactForceEventCallback)(void *user_data,
                                             const struct R3ReadContext *read,
                                             const struct R3ContactForceEvent *event);

typedef struct R3EventCallbacks {
  void *user_data;
  R3CollisionEventCallback collision_event;
  R3ContactForceEventCallback contact_force_event;
} R3EventCallbacks;

typedef struct R3DebugRenderStyle {
  uint32_t subdivisions;
  uint32_t border_subdivisions;
  float collider_dynamic_color[4];
  float collider_fixed_color[4];
  float collider_kinematic_color[4];
  float collider_parentless_color[4];
  float impulse_joint_anchor_color[4];
  float impulse_joint_separation_color[4];
  float multibody_joint_anchor_color[4];
  float multibody_joint_separation_color[4];
  float sleep_color_multiplier[4];
  float sleep_eligible_color_multiplier[4];
  float disabled_color_multiplier[4];
  R3Real rigid_body_axes_length;
  float contact_depth_color[4];
  float contact_normal_color[4];
  R3Real contact_normal_length;
  float soft_body_element_color[4];
  float soft_body_slack_color[4];
  float soft_body_loaded_color[4];
  float soft_body_frame_color[4];
  float collider_aabb_color[4];
  float vertex_pseudo_normal_color[4];
  float edge_pseudo_normal_color[4];
  R3Real pseudo_normal_length;
  float volume_contact_normal_color[4];
  float volume_gradient_color[4];
} R3DebugRenderStyle;

#define R3_OK 0

#define R3_NULL_POINTER 1

#define R3_INVALID_ARGUMENT 2

#define R3_INVALID_HANDLE 3

#define R3_BUFFER_TOO_SMALL 4

#define R3_UNSUPPORTED 5

#define R3_PANIC 6

#define R3_NOT_FOUND 7

#define R3_WORLD_BUSY 8
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

RAPIER_API struct R3SoftBodyMaterial RAPIER_CALL r3DefaultSoftBodyMaterial(void);

RAPIER_API struct R3SoftRecoverySettings RAPIER_CALL r3DefaultSoftRecoverySettings(void);
 
#if defined(RAPIER_FEM)
RAPIER_API struct R3SoftFemParameters RAPIER_CALL r3DefaultSoftFemParameters(void);
#endif

RAPIER_API struct R3SoftBodiesSettings RAPIER_CALL r3DefaultSoftBodiesSettings(void);

RAPIER_API struct R3IntegrationParameters RAPIER_CALL r3DefaultIntegrationParameters(void);

RAPIER_API struct R3IntegrationParameters RAPIER_CALL r3IntegrationParameters(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetIntegrationParameters(struct R3World *world,
                                         const struct R3IntegrationParameters *data);

RAPIER_API struct R3JointDesc RAPIER_CALL r3DefaultJointDesc(void);

RAPIER_API struct R3JointDesc RAPIER_CALL r3FixedJointDesc(void);
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R3JointDesc RAPIER_CALL r3RevoluteJointDesc(void);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3JointDesc RAPIER_CALL r3RevoluteJointDesc(struct R3Vector axis_vector);
#endif

RAPIER_API struct R3JointDesc RAPIER_CALL r3PrismaticJointDesc(struct R3Vector axis_vector);

RAPIER_API struct R3JointDesc RAPIER_CALL r3RopeJointDesc(R3Real length);

RAPIER_API
struct R3JointDesc RAPIER_CALL r3SpringJointDesc(R3Real length,
                                          R3Real stiffness,
                                          R3Real damping);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3JointDesc RAPIER_CALL r3SphericalJointDesc(void);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R3JointDesc RAPIER_CALL r3PinSlotJointDesc(struct R3Vector axis_vector);
#endif

RAPIER_API
struct R3ImpulseJointHandle RAPIER_CALL r3InsertImpulseJoint(struct R3RigidBodyHandle body1,
                                                      struct R3RigidBodyHandle body2,
                                                      const struct R3JointDesc *joint);

RAPIER_API
struct R3MultibodyJointHandle RAPIER_CALL r3InsertMultibodyJoint(struct R3RigidBodyHandle body1,
                                                          struct R3RigidBodyHandle body2,
                                                          const struct R3JointDesc *joint);

RAPIER_API struct R3SoftBodyDesc RAPIER_CALL r3DefaultSoftBodyDesc(void);

RAPIER_API
struct R3SoftBodyHandle RAPIER_CALL r3InsertSoftBody(struct R3World *world,
                                              const struct R3SoftBodyDesc *desc);

RAPIER_API struct R3SoftMeshBindingDesc RAPIER_CALL r3DefaultSoftMeshBindingDesc(void);

RAPIER_API
struct R3ColliderHandle RAPIER_CALL r3InsertDeformableCollider(const struct R3ColliderDesc *collider,
                                                        const struct R3SoftMeshBindingDesc *binding,
                                                        struct R3RigidBodyHandle parent);

RAPIER_API struct R3QueryOptions RAPIER_CALL r3DefaultQueryOptions(void);

RAPIER_API
struct R3RayHit RAPIER_CALL r3CastRay(const struct R3World *world,
                              const struct R3QueryOptions *query_options,
                              struct R3Vector origin,
                              struct R3Vector direction,
                              R3Real max_toi,
                              R3Bool solid);

RAPIER_API
struct R3PointProjection RAPIER_CALL r3ProjectPoint(const struct R3World *world,
                                            const struct R3QueryOptions *query_options,
                                            struct R3Vector point,
                                            R3Real max_distance,
                                            R3Bool solid);

RAPIER_API
struct R3ShapeCastHit RAPIER_CALL r3CastShape(const struct R3World *world,
                                      const struct R3QueryOptions *query_options,
                                      struct R3Pose pose,
                                      struct R3Vector velocity,
                                      const R3SharedShape *shape,
                                      struct R3ShapeCastOptions options);

RAPIER_API
size_t RAPIER_CALL r3IntersectPoint(const struct R3World *world,
                           const struct R3QueryOptions *query_options,
                           struct R3Vector point,
                           struct R3ColliderHandle *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3IntersectShape(const struct R3World *world,
                           const struct R3QueryOptions *query_options,
                           struct R3Pose pose,
                           const R3SharedShape *shape,
                           struct R3ColliderHandle *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3IntersectAabbConservative(const struct R3World *world,
                                       const struct R3QueryOptions *query_options,
                                       struct R3Aabb aabb,
                                       struct R3ColliderHandle *buffer,
                                       size_t capacity);

RAPIER_API
struct R3RayToi RAPIER_CALL r3CastRayToi(const struct R3World *world,
                                  const struct R3QueryOptions *query_options,
                                  struct R3Vector origin,
                                  struct R3Vector direction,
                                  R3Real max_toi,
                                  R3Bool solid);

RAPIER_API
struct R3OptionalRayHit RAPIER_CALL r3TryCastRay(const struct R3World *world,
                                          const struct R3QueryOptions *query_options,
                                          struct R3Vector origin,
                                          struct R3Vector direction,
                                          R3Real max_toi,
                                          R3Bool solid);

RAPIER_API struct R3RigidBodyDesc RAPIER_CALL r3DynamicRigidBodyDesc(void);

RAPIER_API struct R3RigidBodyDesc RAPIER_CALL r3FixedRigidBodyDesc(void);

RAPIER_API struct R3RigidBodyDesc RAPIER_CALL r3KinematicPositionBasedRigidBodyDesc(void);

RAPIER_API struct R3RigidBodyDesc RAPIER_CALL r3KinematicVelocityBasedRigidBodyDesc(void);

RAPIER_API struct R3ShapeDesc RAPIER_CALL r3DefaultShapeDesc(void);

RAPIER_API R3SharedShape *RAPIER_CALL r3ShapeDesc_Build(const struct R3ShapeDesc *desc);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3DefaultColliderDesc(void);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3BallColliderDesc(R3Real radius);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3CuboidColliderDesc(struct R3Vector half_extents);

RAPIER_API
struct R3RigidBodyHandle RAPIER_CALL r3InsertRigidBody(struct R3World *world,
                                                const struct R3RigidBodyDesc *desc);

RAPIER_API
struct R3ColliderHandle RAPIER_CALL r3InsertCollider(struct R3RigidBodyHandle parent,
                                             const struct R3ColliderDesc *desc);

RAPIER_API
struct R3ColliderHandle RAPIER_CALL r3InsertColliderWithoutParent(struct R3World *world,
                                                            const struct R3ColliderDesc *desc);

RAPIER_API struct R3PodLayout RAPIER_CALL r3PodLayout(void);

RAPIER_API struct R3KinematicCharacterController *RAPIER_CALL r3NewKinematicCharacterController(void);

RAPIER_API
R3Status RAPIER_CALL r3FreeKinematicCharacterController(struct R3KinematicCharacterController *controller);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetUp(struct R3KinematicCharacterController *controller,
                                                    struct R3Vector up);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetOffset(struct R3KinematicCharacterController *controller,
                                                        struct R3CharacterLength offset);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetSlide(struct R3KinematicCharacterController *controller,
                                                       R3Bool enabled);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetSlopes(struct R3KinematicCharacterController *controller,
                                                        R3Real max_climb_angle,
                                                        R3Real min_slide_angle);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetAutostep(struct R3KinematicCharacterController *controller,
                                                          R3Bool enabled,
                                                          struct R3CharacterLength max_height,
                                                          struct R3CharacterLength min_width,
                                                          R3Bool include_dynamic_bodies);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetSnapToGround(struct R3KinematicCharacterController *controller,
                                                                R3Bool enabled,
                                                                struct R3CharacterLength distance);

RAPIER_API
struct R3Vector RAPIER_CALL r3KinematicCharacterController_Up(const struct R3KinematicCharacterController *controller);

RAPIER_API
struct R3CharacterLength RAPIER_CALL r3KinematicCharacterController_Offset(const struct R3KinematicCharacterController *controller);

RAPIER_API
struct R3CharacterAutostep RAPIER_CALL r3KinematicCharacterController_Autostep(const struct R3KinematicCharacterController *controller);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SetNormalNudgeFactor(struct R3KinematicCharacterController *controller,
                                                                     R3Real value);

RAPIER_API
R3Real RAPIER_CALL r3KinematicCharacterController_NormalNudgeFactor(const struct R3KinematicCharacterController *controller);

RAPIER_API
struct R3CharacterMovement RAPIER_CALL r3KinematicCharacterController_MoveShape(const struct R3World *world,
                                                                          const struct R3QueryOptions *options,
                                                                          struct R3KinematicCharacterController *controller,
                                                                          R3Real dt,
                                                                          const R3SharedShape *shape,
                                                                          struct R3Pose pose,
                                                                          struct R3Vector desired_translation);

RAPIER_API
size_t RAPIER_CALL r3KinematicCharacterController_Collisions(const struct R3KinematicCharacterController *controller,
                                                     struct R3CharacterCollision *buffer,
                                                     size_t capacity);

RAPIER_API
R3Status RAPIER_CALL r3KinematicCharacterController_SolveCharacterCollisionImpulses(const struct R3KinematicCharacterController *controller,
                                                                                const R3SharedShape *shape,
                                                                                R3Real dt,
                                                                                R3Real mass,
                                                                                const struct R3QueryOptions *options);

RAPIER_API struct R3PidController *RAPIER_CALL r3NewPidController(void);

RAPIER_API R3Status RAPIER_CALL r3FreePidController(struct R3PidController *controller);

RAPIER_API struct R3PidGains RAPIER_CALL r3PidController_Gains(const struct R3PidController *controller);

RAPIER_API
R3Status RAPIER_CALL r3PidController_SetGains(struct R3PidController *controller,
                                       struct R3PidGains gains);

RAPIER_API
R3Status RAPIER_CALL r3PidController_SetAxes(struct R3PidController *controller,
                                      uint32_t axes);

RAPIER_API uint32_t RAPIER_CALL r3PidController_Axes(const struct R3PidController *controller);

RAPIER_API R3Status RAPIER_CALL r3PidController_ResetIntegrals(struct R3PidController *controller);

RAPIER_API struct R3PdController RAPIER_CALL r3DefaultPdController(void);

RAPIER_API
struct R3VelocityCorrection RAPIER_CALL r3PdController_RigidBodyCorrection(const struct R3PdController *controller,
                                                                     struct R3RigidBodyHandle body,
                                                                     struct R3Pose target_pose,
                                                                     struct R3Vector target_linvel,
                                                                     R3AngVector target_angvel);

RAPIER_API
struct R3VelocityCorrection RAPIER_CALL r3PidController_RigidBodyCorrection(struct R3PidController *controller,
                                                                      R3Real dt,
                                                                      struct R3RigidBodyHandle body,
                                                                      struct R3Pose target_pose,
                                                                      struct R3Vector target_linvel,
                                                                      R3AngVector target_angvel);

RAPIER_API
struct R3CharacterControllerSettings RAPIER_CALL r3KinematicCharacterController_Settings(const struct R3KinematicCharacterController *controller);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3WheelTuning RAPIER_CALL r3DefaultWheelTuning(void);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3DynamicRayCastVehicleController *RAPIER_CALL r3NewDynamicRayCastVehicleController(struct R3RigidBodyHandle chassis);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3FreeDynamicRayCastVehicleController(struct R3DynamicRayCastVehicleController *controller);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r3DynamicRayCastVehicleController_AddWheel(struct R3DynamicRayCastVehicleController *controller,
                                                         struct R3Vector connection,
                                                         struct R3Vector direction,
                                                         struct R3Vector axle,
                                                         R3Real rest_length,
                                                         R3Real radius,
                                                         const struct R3WheelTuning *tuning);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3DynamicRayCastVehicleController_SetAxes(struct R3DynamicRayCastVehicleController *controller,
                                                           size_t up,
                                                           size_t forward);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3DynamicRayCastVehicleController_SetWheelControls(struct R3DynamicRayCastVehicleController *controller,
                                                                     size_t index,
                                                                     R3Real steering,
                                                                     R3Real engine_force,
                                                                     R3Real brake);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3DynamicRayCastVehicleController_UpdateVehicle(struct R3DynamicRayCastVehicleController *controller,
                                                                 R3Real dt,
                                                                 const struct R3QueryOptions *options);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Real RAPIER_CALL r3DynamicRayCastVehicleController_CurrentVehicleSpeed(const struct R3DynamicRayCastVehicleController *controller);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r3DynamicRayCastVehicleController_Wheels(const struct R3DynamicRayCastVehicleController *controller,
                                                      struct R3WheelState *buffer,
                                                      size_t capacity);
#endif

RAPIER_API
R3Status RAPIER_CALL r3RigidBodyPropagateModifiedBodyPositionsToColliders(struct R3World *world);

RAPIER_API
size_t RAPIER_CALL r3ActiveRigidBodies(const struct R3World *world,
                               struct R3RigidBodyHandle *buffer,
                               size_t capacity);

RAPIER_API R3Status RAPIER_CALL r3RigidBody_WakeUp(struct R3RigidBodyHandle handle, R3Bool strong);

RAPIER_API struct R3ErrorHandler RAPIER_CALL r3SetErrorHandler(struct R3ErrorHandler handler);

RAPIER_API R3Status RAPIER_CALL r3LastStatus(void);

RAPIER_API const char *RAPIER_CALL r3LastError(void);

RAPIER_API R3SharedShape *RAPIER_CALL r3BallSharedShape(R3Real radius);

RAPIER_API R3SharedShape *RAPIER_CALL r3CuboidSharedShape(struct R3Vector half_extents);

RAPIER_API
R3SharedShape *RAPIER_CALL r3RoundCuboidSharedShape(struct R3Vector half_extents,
                                              R3Real border_radius);

RAPIER_API
R3SharedShape *RAPIER_CALL r3CapsuleSharedShape(struct R3Vector a,
                                         struct R3Vector b,
                                         R3Real radius);

RAPIER_API R3SharedShape *RAPIER_CALL r3SegmentSharedShape(struct R3Vector a, struct R3Vector b);

RAPIER_API
R3SharedShape *RAPIER_CALL r3TriangleSharedShape(struct R3Vector a,
                                          struct R3Vector b,
                                          struct R3Vector c);

RAPIER_API R3SharedShape *RAPIER_CALL r3HalfspaceSharedShape(struct R3Vector normal);
 
#if defined(RAPIER_DIM3)
RAPIER_API R3SharedShape *RAPIER_CALL r3CylinderSharedShape(R3Real half_height, R3Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R3SharedShape *RAPIER_CALL r3ConeSharedShape(R3Real half_height, R3Real radius);
#endif

RAPIER_API R3SharedShape *RAPIER_CALL r3CompoundSharedShape(struct R3CompoundShapeView children);

RAPIER_API R3Status RAPIER_CALL r3RemoveCollider(struct R3ColliderHandle handle, R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3RemoveImpulseJoint(struct R3ImpulseJointHandle handle, R3Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r3ImpulseJointHandles(const struct R3World *world,
                                 struct R3ImpulseJointHandle *buffer,
                                 size_t capacity);

RAPIER_API
R3Status RAPIER_CALL r3RemoveMultibodyJoint(struct R3MultibodyJointHandle handle,
                                     R3Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r3MultibodyJointHandles(const struct R3World *world,
                                   struct R3MultibodyJointHandle *buffer,
                                   size_t capacity);

RAPIER_API struct R3JointBodies RAPIER_CALL r3ImpulseJoint_Bodies(struct R3ImpulseJointHandle handle);

RAPIER_API struct R3InverseKinematicsOptions RAPIER_CALL r3DefaultInverseKinematicsOptions(void);

RAPIER_API size_t RAPIER_CALL r3MultibodyJoint_Ndofs(struct R3MultibodyJointHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3MultibodyJoint_InverseKinematics(struct R3MultibodyJointHandle handle,
                                                 const struct R3InverseKinematicsOptions *options,
                                                 struct R3Pose target,
                                                 R3IkJointCanMove can_move,
                                                 void *user_data,
                                                 R3Real *displacements,
                                                 size_t count);

RAPIER_API
R3Status RAPIER_CALL r3MultibodyJoint_ApplyDisplacements(struct R3MultibodyJointHandle handle,
                                                  const R3Real *displacements,
                                                  size_t count);

RAPIER_API R3Status RAPIER_CALL r3FreeSharedShape(R3SharedShape *object);

RAPIER_API R3SharedShape *RAPIER_CALL r3SharedShape_Clone(const R3SharedShape *object);

RAPIER_API size_t RAPIER_CALL r3RigidBodyCount(const struct R3World *world);

RAPIER_API
size_t RAPIER_CALL r3RigidBodyHandles(const struct R3World *world,
                              struct R3RigidBodyHandle *buffer,
                              size_t capacity);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_Contains(struct R3RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r3ColliderCount(const struct R3World *world);

RAPIER_API
size_t RAPIER_CALL r3ColliderHandles(const struct R3World *world,
                            struct R3ColliderHandle *buffer,
                            size_t capacity);

RAPIER_API R3Bool RAPIER_CALL r3Collider_Contains(struct R3ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r3SoftBodyCount(const struct R3World *world);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyHandles(const struct R3World *world,
                             struct R3SoftBodyHandle *buffer,
                             size_t capacity);

RAPIER_API R3Bool RAPIER_CALL r3SoftBody_Contains(struct R3SoftBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3RemoveRigidBody(struct R3RigidBodyHandle handle,
                                R3Bool remove_attached_colliders);

RAPIER_API R3Real RAPIER_CALL r3TimeStep(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetTimeStep(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3MinCcdDt(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetMinCcdDt(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3LengthUnit(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetLengthUnit(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3WarmstartCoefficient(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetWarmstartCoefficient(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3NormalizedAllowedLinearError(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetNormalizedAllowedLinearError(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3NormalizedMaxCorrectiveVelocity(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetNormalizedMaxCorrectiveVelocity(struct R3World *world,
                                                     R3Real value);

RAPIER_API R3Real RAPIER_CALL r3NormalizedPredictionDistance(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetNormalizedPredictionDistance(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3NormalizedMaxLinearVelocity(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetNormalizedMaxLinearVelocity(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3NormalizedContactRecycleDistance(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetNormalizedContactRecycleDistance(struct R3World *world,
                                                      R3Real value);

RAPIER_API size_t RAPIER_CALL r3NumSolverIterations(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetNumSolverIterations(struct R3World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r3NumInternalPgsIterations(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetNumInternalPgsIterations(struct R3World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r3NumInternalStabilizationIterations(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetNumInternalStabilizationIterations(struct R3World *world,
                                                        size_t value);

RAPIER_API size_t RAPIER_CALL r3MaxCcdSubsteps(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetMaxCcdSubsteps(struct R3World *world, size_t value);

RAPIER_API R3Bool RAPIER_CALL r3ContactClustering(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetContactClustering(struct R3World *world, R3Bool value);

RAPIER_API R3Bool RAPIER_CALL r3ContactRecycling(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetContactRecycling(struct R3World *world, R3Bool value);

RAPIER_API R3Bool RAPIER_CALL r3FrictionInBiasPass(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetFrictionInBiasPass(struct R3World *world, R3Bool value);

RAPIER_API R3Bool RAPIER_CALL r3WarmstartJoints(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetWarmstartJoints(struct R3World *world, R3Bool value);

RAPIER_API struct R3SpringCoefficients RAPIER_CALL r3ContactSoftness(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetContactSoftness(struct R3World *world,
                                   struct R3SpringCoefficients value);

RAPIER_API struct R3SpringCoefficients RAPIER_CALL r3StaticContactSoftness(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3SetStaticContactSoftness(struct R3World *world,
                                          struct R3SpringCoefficients value);

RAPIER_API
R3Status RAPIER_CALL r3ContactModificationContext_UpdateAsOnewayPlatform(struct R3ContactModificationContext *context,
                                                                     struct R3Vector allowed_local_n1,
                                                                     R3Real allowed_angle);

RAPIER_API
R3Status RAPIER_CALL r3ContactModificationContext_SetTangentVelocity(struct R3ContactModificationContext *context,
                                                                struct R3Vector velocity);

RAPIER_API struct R3EventCollector *RAPIER_CALL r3NewEventCollector(void);

RAPIER_API R3Status RAPIER_CALL r3FreeEventCollector(struct R3EventCollector *events);

RAPIER_API R3Status RAPIER_CALL r3EventCollector_Clear(struct R3EventCollector *events);

RAPIER_API
size_t RAPIER_CALL r3EventCollector_CollisionEvents(const struct R3EventCollector *events,
                                            struct R3CollisionEvent *buffer,
                                            size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3EventCollector_ContactForceEvents(const struct R3EventCollector *events,
                                                struct R3ContactForceEvent *buffer,
                                                size_t capacity);

RAPIER_API size_t RAPIER_CALL r3EventCollector_TearEventCount(const struct R3EventCollector *events);

RAPIER_API
struct R3SoftBodyTearEvent *RAPIER_CALL r3EventCollector_TearEvent(const struct R3EventCollector *events,
                                                            size_t index);

RAPIER_API struct R3Vector RAPIER_CALL r3Gravity(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetGravity(struct R3World *world, struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3Step(struct R3World *world,
                   const struct R3PhysicsHooks *hooks,
                   const struct R3EventCollector *events);

RAPIER_API
R3Status RAPIER_CALL r3DetectCollisions(struct R3World *world,
                                const struct R3PhysicsHooks *hooks,
                                const struct R3EventCollector *events);

RAPIER_API struct R3ByteView RAPIER_CALL r3Bytes_Data(const struct R3Bytes *bytes);

RAPIER_API R3Status RAPIER_CALL r3FreeBytes(struct R3Bytes *bytes);

RAPIER_API struct R3Bytes *RAPIER_CALL r3SerializeWorld(const struct R3World *world);

RAPIER_API struct R3World *RAPIER_CALL r3DeserializeWorld(const uint8_t *data, size_t count);

RAPIER_API
size_t RAPIER_CALL r3DebugRender(const struct R3World *world,
                        uint32_t mode,
                        struct R3DebugLine *buffer,
                        size_t capacity);

RAPIER_API R3Status RAPIER_CALL r3SoftBodiesSetResweepStrain(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3SoftBodiesResweepStrain(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SoftBodiesSetContactStiffening(struct R3World *world, R3Real value);

RAPIER_API R3Real RAPIER_CALL r3SoftBodiesContactStiffening(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SoftBodiesSetMaxExtraSubsteps(struct R3World *world, size_t value);

RAPIER_API size_t RAPIER_CALL r3SoftBodiesMaxExtraSubsteps(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetAuthoredVelocityMargin(struct R3World *world,
                                                    R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetEdgeSpeculation(struct R3World *world, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetInvertedCellDetection(struct R3World *world,
                                                   R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetSelfCrossingDetection(struct R3World *world,
                                                   R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetDetectionMotionGating(struct R3World *world,
                                                   R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetCrossBodyDetection(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetSelfStandDown(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetCrossBodyExpelGate(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetEdgeStandDown(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetCrossingRepulsion(struct R3World *world, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetCrossingRepulsionGuide(struct R3World *world,
                                                    R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetCrossingRepulsionSelfGuide(struct R3World *world,
                                                         R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetRecoveryPace(struct R3World *world, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapConstraints(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapRigid(struct R3World *world, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetOverlapSkipSelfTangled(struct R3World *world,
                                                     R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetOverlapEdgeStandDown(struct R3World *world,
                                                   R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetOverlapConstraintPace(struct R3World *world,
                                                   R3Real value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapSkinVolume(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapKeptDepth(struct R3World *world, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapSelfRegions(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapNormalPush(struct R3World *world, R3Bool value);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapMultiVolume(struct R3World *world, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetOverlapProgressMargin(struct R3World *world,
                                                   R3Real value);
 
#if defined(RAPIER_FEM)
RAPIER_API R3Status RAPIER_CALL r3FemSetLinearTolerance(struct R3World *world, R3Real value);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API R3Status RAPIER_CALL r3FemSetMaxLinearIterations(struct R3World *world, size_t value);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API R3Status RAPIER_CALL r3FemSetMaxDenseDofs(struct R3World *world, size_t value);
#endif

RAPIER_API R3Status RAPIER_CALL r3SetNumThreads(struct R3World *world, size_t num_threads);

RAPIER_API R3Status RAPIER_CALL r3ClearThreadPool(struct R3World *world);

RAPIER_API size_t RAPIER_CALL r3NumThreads(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3SetCountersEnabled(struct R3World *world, R3Bool enabled);

RAPIER_API double RAPIER_CALL r3StepTimeMs(const struct R3World *world);

RAPIER_API struct R3World *RAPIER_CALL r3DeserializeRigidState(const uint8_t *data, size_t count);

RAPIER_API struct R3QueryFilter RAPIER_CALL r3DefaultQueryFilter(void);

RAPIER_API struct R3ShapeCastOptions RAPIER_CALL r3DefaultShapeCastOptions(void);

RAPIER_API R3Status RAPIER_CALL r3RemoveSoftBody(struct R3SoftBodyHandle handle);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_WakeUp(struct R3SoftBodyHandle handle);

RAPIER_API R3Status RAPIER_CALL r3FreeSoftBodyTearEvent(struct R3SoftBodyTearEvent *event);

RAPIER_API
struct R3SoftBodyHandle RAPIER_CALL r3SoftBodyTearEvent_SoftBody(const struct R3SoftBodyTearEvent *event);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_Bodies(const struct R3SoftBodyTearEvent *event,
                                       struct R3SoftBodyHandle *buffer,
                                       size_t capacity);

RAPIER_API
struct R3ParticleDestination RAPIER_CALL r3SoftBodyTearEvent_ParticleDestination(const struct R3SoftBodyTearEvent *event,
                                                                            uint32_t particle);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_TornEdges(const struct R3SoftBodyTearEvent *event,
                                           uint32_t *buffer,
                                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_TornCells(const struct R3SoftBodyTearEvent *event,
                                           uint32_t *buffer,
                                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_RemovedEdges(const struct R3SoftBodyTearEvent *event,
                                              uint32_t *buffer,
                                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_SplitParticles(const struct R3SoftBodyTearEvent *event,
                                                uint32_t *buffer,
                                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_InsertedParticles(const struct R3SoftBodyTearEvent *event,
                                                   uint32_t *buffer,
                                                   size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_PieceParticles(const struct R3SoftBodyTearEvent *event,
                                                size_t piece_index,
                                                uint32_t *buffer,
                                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_Clusters(const struct R3SoftBodyTearEvent *event,
                                         struct R3SoftClusterSplit *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyTearEvent_MovedJoints(const struct R3SoftBodyTearEvent *event,
                                             struct R3SoftJointMove *buffer,
                                             size_t capacity);

RAPIER_API
struct R3SoftBodyTearEvent *RAPIER_CALL r3SoftBody_Tear(struct R3SoftBodyHandle handle,
                                                const uint32_t *edges,
                                                size_t edge_count,
                                                const uint32_t *cells,
                                                size_t cell_count);

RAPIER_API
uint32_t RAPIER_CALL r3SoftBody_AddCluster(struct R3SoftBodyHandle handle,
                                   const uint32_t *particles,
                                   size_t count);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_RemoveCluster(struct R3SoftBodyHandle handle,
                                       uint32_t cluster);

RAPIER_API
struct R3OptionalParticleDestination RAPIER_CALL r3SoftBodyTearEvent_TryParticleDestination(const struct R3SoftBodyTearEvent *event,
                                                                                        uint32_t particle);

RAPIER_API
struct R3SoftBodyTearEvent *RAPIER_CALL r3CutSoftBody(struct R3SoftBodyHandle handle,
                                               const struct R3Vector *blade);

RAPIER_API struct R3VolumeMeshParameters RAPIER_CALL r3NewVolumeMeshParameters(R3Real cell_size);

RAPIER_API struct R3BuildInfo RAPIER_CALL r3BuildInfo(void);

RAPIER_API const char *RAPIER_CALL r3Version(void);

RAPIER_API const char *RAPIER_CALL r3BuildProfile(void);

RAPIER_API struct R3BuildFeatures RAPIER_CALL r3BuildFeatures(void);

RAPIER_API
R3SharedShape *RAPIER_CALL r3HeightfieldSharedShape(struct R3RealView heights,
                                             size_t rows,
                                             size_t columns,
                                             struct R3Vector scale);

RAPIER_API
struct R3Aabb RAPIER_CALL r3SharedShape_ComputeAabb(const R3SharedShape *shape,
                                             struct R3Pose pose);

RAPIER_API
struct R3MassProperties RAPIER_CALL r3SharedShape_MassProperties(const R3SharedShape *shape,
                                                          R3Real density);

RAPIER_API
R3Bool RAPIER_CALL r3SharedShape_ContainsPoint(const R3SharedShape *shape,
                                        struct R3Pose pose,
                                        struct R3Vector point);

RAPIER_API
size_t RAPIER_CALL r3ContactPairs(const struct R3World *world,
                         struct R3ContactPair *buffer,
                         size_t capacity);

RAPIER_API
struct R3ContactPair RAPIER_CALL r3ContactPair(struct R3ColliderHandle collider1,
                                       struct R3ColliderHandle collider2);

RAPIER_API
size_t RAPIER_CALL r3IntersectionPairs(const struct R3World *world,
                              struct R3IntersectionPair *buffer,
                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3ContactPoints(struct R3ColliderHandle collider1,
                          struct R3ColliderHandle collider2,
                          struct R3ContactPoint *buffer,
                          size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3MultibodyJoint_GeneralizedVelocity(struct R3MultibodyJointHandle handle,
                                                R3Real *buffer,
                                                size_t capacity);

RAPIER_API
R3Status RAPIER_CALL r3MultibodyJoint_SetGeneralizedVelocity(struct R3MultibodyJointHandle handle,
                                                       const R3Real *values,
                                                       size_t count);

RAPIER_API
R3Status RAPIER_CALL r3CheckAbi(uint32_t version,
                        uint32_t dimension,
                        size_t real_size,
                        size_t vector_size,
                        size_t pose_size,
                        uint32_t features);

RAPIER_API
size_t RAPIER_CALL r3QuarantinedRigidBodies(const struct R3World *world,
                                    struct R3RigidBodyHandle *buffer,
                                    size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3QuarantinedColliders(const struct R3World *world,
                                 struct R3ColliderHandle *buffer,
                                 size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3QuarantinedSoftBodies(const struct R3World *world,
                                   struct R3SoftBodyHandle *buffer,
                                   size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API uint32_t RAPIER_CALL r3FrictionModel(const struct R3World *world);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R3Status RAPIER_CALL r3SetFrictionModel(struct R3World *world, uint32_t value);
#endif

RAPIER_API R3Real RAPIER_CALL r3Sin(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Cos(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Tan(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Asin(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Acos(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Atan2(R3Real y, R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Exp(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Ln(R3Real x);

RAPIER_API R3Real RAPIER_CALL r3Powf(R3Real base, R3Real exponent);

RAPIER_API
struct R3ShapeMesh *RAPIER_CALL r3SharedShape_Tessellate(const R3SharedShape *shape,
                                                 uint32_t subdivisions);

RAPIER_API
size_t RAPIER_CALL r3ShapeMesh_Triangles(const struct R3ShapeMesh *mesh,
                                struct R3Vector *buffer,
                                size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3ShapeMesh_Lines(const struct R3ShapeMesh *mesh,
                            struct R3Vector *buffer,
                            size_t capacity);

RAPIER_API R3Status RAPIER_CALL r3FreeShapeMesh(struct R3ShapeMesh *mesh);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3SharedShape *RAPIER_CALL r3RoundCylinderSharedShape(R3Real half_height,
                                                R3Real radius,
                                                R3Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3SharedShape *RAPIER_CALL r3RoundConeSharedShape(R3Real half_height,
                                            R3Real radius,
                                            R3Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3TriMeshData *RAPIER_CALL r3SharedShape_ToTrimesh(const R3SharedShape *shape,
                                                   uint32_t ntheta,
                                                   uint32_t nphi);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r3TriMeshData_Vertices(const struct R3TriMeshData *mesh,
                                  struct R3Vector *buffer,
                                  size_t capacity);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
size_t RAPIER_CALL r3TriMeshData_Indices(const struct R3TriMeshData *mesh,
                                 uint32_t *buffer,
                                 size_t capacity);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API R3Status RAPIER_CALL r3FreeTriMeshData(struct R3TriMeshData *mesh);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R3UrdfLoaderOptions RAPIER_CALL r3DefaultUrdfLoaderOptions(void);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeUrdfRobot(struct R3UrdfRobot *object);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3UrdfRobot *RAPIER_CALL r3UrdfRobotFromFile(const char *path,
                                              const struct R3UrdfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3UrdfRobot_AppendTransform(struct R3UrdfRobot *robot,
                                          struct R3Pose transform);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeUrdfRobotHandles(struct R3UrdfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3UrdfRobotHandles *RAPIER_CALL r3UrdfRobot_InsertUsingImpulseJoints(struct R3World *world,
                                                                       const struct R3UrdfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3UrdfRobotHandles *RAPIER_CALL r3UrdfRobot_InsertUsingMultibodyJoints(struct R3World *world,
                                                                         const struct R3UrdfRobot *robot,
                                                                         uint8_t options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3UrdfRobotHandles_Bodies(const struct R3UrdfRobotHandles *handles,
                                     struct R3RigidBodyHandle *buffer,
                                     size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R3MjcfLoaderOptions RAPIER_CALL r3DefaultMjcfLoaderOptions(void);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeMjcfRobot(struct R3MjcfRobot *object);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3MjcfRobot *RAPIER_CALL r3MjcfRobotFromFile(const char *path,
                                              const struct R3MjcfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3MjcfRobot_AppendTransform(struct R3MjcfRobot *robot,
                                          struct R3Pose transform);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeMjcfRobotHandles(struct R3MjcfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3MjcfRobotHandles *RAPIER_CALL r3MjcfRobot_InsertUsingImpulseJoints(struct R3World *world,
                                                                       const struct R3MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3MjcfRobotHandles *RAPIER_CALL r3MjcfRobot_InsertUsingMultibodyJoints(struct R3World *world,
                                                                         const struct R3MjcfRobot *robot,
                                                                         uint8_t options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfRobotHandles_Bodies(const struct R3MjcfRobotHandles *handles,
                                     struct R3RigidBodyHandle *buffer,
                                     size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R3Vector RAPIER_CALL r3MjcfRobot_Gravity(const struct R3MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3MjcfRobot_BodyCount(const struct R3MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3MjcfRobot_BodyColliderCount(const struct R3MjcfRobot *robot, size_t body);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3MjcfRobot_SetBodyColliderCollisionGroups(struct R3MjcfRobot *robot,
                                                            size_t body,
                                                            size_t collider,
                                                            struct R3InteractionGroups groups);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3MjcfRobot_KeyframeCount(const struct R3MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfRobot_KeyframeName(const struct R3MjcfRobot *robot,
                                    size_t key,
                                    char *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3MjcfRobot_AppendKeyframe(struct R3MjcfRobot *robot,
                                         const struct R3MjcfRobot *source,
                                         size_t key);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfRobot_KeyframeControls(const struct R3MjcfRobot *robot,
                                        size_t key,
                                        R3Real *buffer,
                                        size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3MjcfRobotHandles_ActuatorCount(const struct R3MjcfRobotHandles *handles);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3MjcfRobotHandles_ApplyKeyframe(const struct R3MjcfRobotHandles *handles,
                                                const struct R3MjcfRobot *robot,
                                                size_t key);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3Status RAPIER_CALL r3MjcfRobotHandles_ApplyControlsScaled(const struct R3MjcfRobotHandles *handles,
                                                       const R3Real *controls,
                                                       size_t count,
                                                       R3Real gain);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3MjcfRobot_BodyVisualCount(const struct R3MjcfRobot *robot, size_t body);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
const R3MjcfVisualMesh *RAPIER_CALL r3MjcfRobot_BodyVisual(const struct R3MjcfRobot *robot,
                                                    size_t body,
                                                    size_t visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API struct R3MjcfVisualMeshInfo RAPIER_CALL r3MjcfVisualMesh_Info(const R3MjcfVisualMesh *visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3SharedShape *RAPIER_CALL r3MjcfVisualMesh_CloneShape(const R3MjcfVisualMesh *visual);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfVisualMesh_Uvs(const R3MjcfVisualMesh *visual,
                                float *buffer,
                                size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfVisualMesh_Normals(const R3MjcfVisualMesh *visual,
                                    float *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
size_t RAPIER_CALL r3MjcfVisualMesh_Texture(const R3MjcfVisualMesh *visual,
                                    char *buffer,
                                    size_t capacity);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3UrdfRobot *RAPIER_CALL r3UrdfRobotFromString(const char *urdf,
                                                const char *mesh_dir,
                                                const struct R3UrdfLoaderOptions *options);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeMjcfContactHooks(struct R3MjcfContactHooks *hooks);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3MjcfContactHooks *RAPIER_CALL r3MjcfRobotHandles_ContactHooks(const struct R3MjcfRobotHandles *handles,
                                                                 const struct R3MjcfRobot *robot);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3PhysicsHooks RAPIER_CALL r3MjcfContactHooks_PhysicsHooks(const struct R3MjcfContactHooks *hooks);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API R3Status RAPIER_CALL r3FreeLoadedMeshes(struct R3LoadedMeshes *meshes);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3LoadedMeshes *RAPIER_CALL r3LoadedMeshesFromFile(const char *path,
                                                    uint32_t converter,
                                                    uint32_t trimesh_flags,
                                                    struct R3Vector scale);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API size_t RAPIER_CALL r3LoadedMeshes_Count(const struct R3LoadedMeshes *meshes);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
R3SharedShape *RAPIER_CALL r3LoadedMeshes_CloneShape(const struct R3LoadedMeshes *meshes,
                                              size_t index);
#endif
 
#if (defined(RAPIER_ROBOTICS) && defined(RAPIER_DIM3) && defined(RAPIER_F32))
RAPIER_API
struct R3Pose RAPIER_CALL r3LoadedMeshes_Pose(const struct R3LoadedMeshes *meshes,
                                      size_t index);
#endif

RAPIER_API struct R3Pose RAPIER_CALL r3RigidBody_Position(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3RigidBody_Translation(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3RigidBody_Linvel(struct R3RigidBodyHandle handle);

RAPIER_API R3AngVector RAPIER_CALL r3RigidBody_Angvel(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsSleeping(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsEnabled(struct R3RigidBodyHandle handle);

RAPIER_API struct R3UserData RAPIER_CALL r3RigidBody_UserData(struct R3RigidBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetPosition(struct R3RigidBodyHandle handle,
                                      struct R3Pose value,
                                      R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetTranslation(struct R3RigidBodyHandle handle,
                                         struct R3Vector value,
                                         R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetLinvel(struct R3RigidBodyHandle handle,
                                    struct R3Vector value,
                                    R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAngvel(struct R3RigidBodyHandle handle,
                                    R3AngVector value,
                                    R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetNextKinematicPosition(struct R3RigidBodyHandle handle,
                                                     struct R3Pose value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetNextKinematicTranslation(struct R3RigidBodyHandle handle,
                                                        struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetGravityScale(struct R3RigidBodyHandle handle,
                                           R3Real value,
                                           R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetLinearDamping(struct R3RigidBodyHandle handle,
                                            R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAngularDamping(struct R3RigidBodyHandle handle,
                                             R3Real value);

RAPIER_API R3Status RAPIER_CALL r3RigidBody_SetEnabled(struct R3RigidBodyHandle handle, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetUserData(struct R3RigidBodyHandle handle,
                                       struct R3UserData value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_ApplyImpulse(struct R3RigidBodyHandle handle,
                                       struct R3Vector value,
                                       R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_ApplyImpulseAtPoint(struct R3RigidBodyHandle handle,
                                                struct R3Vector value,
                                                struct R3Vector point,
                                                R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_AddForce(struct R3RigidBodyHandle handle,
                                   struct R3Vector value,
                                   R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3RigidBody_ResetForces(struct R3RigidBodyHandle handle, R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3RigidBody_Sleep(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Pose RAPIER_CALL r3Collider_Position(struct R3ColliderHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3Collider_Translation(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_Friction(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_Restitution(struct R3ColliderHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3Collider_IsSensor(struct R3ColliderHandle handle);

RAPIER_API struct R3RigidBodyHandle RAPIER_CALL r3Collider_Parent(struct R3ColliderHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetPosition(struct R3ColliderHandle handle,
                                    struct R3Pose value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetTranslation(struct R3ColliderHandle handle,
                                       struct R3Vector value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetFriction(struct R3ColliderHandle handle, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetRestitution(struct R3ColliderHandle handle, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetSensor(struct R3ColliderHandle handle, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetCollisionGroups(struct R3ColliderHandle handle,
                                            struct R3InteractionGroups value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetUserData(struct R3ColliderHandle handle,
                                     struct R3UserData value);

RAPIER_API
struct R3Vector RAPIER_CALL r3SoftBody_ParticlePosition(struct R3SoftBodyHandle handle,
                                                 size_t index);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_ParticlePositions(struct R3SoftBodyHandle handle,
                                        struct R3Vector *buffer,
                                        size_t capacity);

RAPIER_API struct R3SoftBodyMaterial RAPIER_CALL r3SoftBody_Material(struct R3SoftBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetParticlePosition(struct R3SoftBodyHandle handle,
                                              size_t index,
                                              struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetMaterial(struct R3SoftBodyHandle handle,
                                     const struct R3SoftBodyMaterial *data);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_AddParticleForce(struct R3SoftBodyHandle handle,
                                           size_t index,
                                           struct R3Vector value,
                                           R3Bool wake_up);

RAPIER_API
size_t RAPIER_CALL r3RigidBodyReadStates(const struct R3World *world,
                                  const struct R3RigidBodyHandle *handles,
                                  size_t handle_count,
                                  struct R3RigidBodyState *states,
                                  size_t capacity);

RAPIER_API struct R3JointDesc RAPIER_CALL r3ImpulseJoint_Desc(struct R3ImpulseJointHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetDesc(struct R3ImpulseJointHandle handle,
                                     const struct R3JointDesc *desc,
                                     R3Bool wake_up);

RAPIER_API uint16_t RAPIER_CALL r3Collider_ActiveCollisionTypes(struct R3ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3Collider_ActiveHooks(struct R3ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3Collider_FrictionCombineRule(struct R3ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3Collider_RestitutionCombineRule(struct R3ColliderHandle handle);

RAPIER_API struct R3Pose RAPIER_CALL r3Collider_PositionWrtParent(struct R3ColliderHandle handle);

RAPIER_API int8_t RAPIER_CALL r3RigidBody_DominanceGroup(struct R3RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r3RigidBody_AdditionalSolverIterations(struct R3RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r3RigidBody_AdditionalPgsIterations(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsFastRotationAllowed(struct R3RigidBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetRotation(struct R3ColliderHandle handle,
                                    struct R3Rotation value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAllowFastRotation(struct R3RigidBodyHandle handle,
                                                 R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3ShapeDesc_SetTrimesh(struct R3ShapeDesc *desc,
                                     struct R3VectorView vertices,
                                     struct R3TriangleView indices,
                                     uint32_t flags);

RAPIER_API
R3Status RAPIER_CALL r3ShapeDesc_SetPolyline(struct R3ShapeDesc *desc,
                                      struct R3VectorView vertices,
                                      struct R3EdgeView indices,
                                      uint32_t flags);

RAPIER_API
R3Status RAPIER_CALL r3ShapeDesc_SetConvexHull(struct R3ShapeDesc *desc,
                                         struct R3VectorView vertices);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetParticles(struct R3SoftBodyDesc *desc,
                                           struct R3VectorView positions);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetSurfaceMesh(struct R3SoftBodyDesc *desc,
                                              struct R3VectorView vertices,
                                              R3SurfaceElementView elements);
 
#if defined(RAPIER_DIM2)
RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetTrimesh(struct R3SoftBodyDesc *desc,
                                         struct R3VectorView vertices,
                                         struct R3TriangleView triangles);
#endif

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetAppended(struct R3SoftBodyDesc *desc,
                                          struct R3SoftBodyDescView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetAddedEdges(struct R3SoftBodyDesc *desc,
                                             struct R3EdgeView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetSkin(struct R3SoftBodyDesc *desc,
                                      struct R3VectorView vertices,
                                      R3SurfaceElementView elements);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetMasses(struct R3SoftBodyDesc *desc,
                                        struct R3RealView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetPinnedParticles(struct R3SoftBodyDesc *desc,
                                                  struct R3IndexView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetEdges(struct R3SoftBodyDesc *desc,
                                       struct R3EdgeView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetBendEdges(struct R3SoftBodyDesc *desc,
                                            struct R3EdgeView view);

RAPIER_API R3Status RAPIER_CALL r3SoftBodyDesc_SetCells(struct R3SoftBodyDesc *desc, R3CellView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetSurface(struct R3SoftBodyDesc *desc,
                                         R3SurfaceElementView view);

RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetTensionOnlyEdges(struct R3SoftBodyDesc *desc,
                                                    struct R3IndexView view);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetDihedrals(struct R3SoftBodyDesc *desc,
                                           struct R3DihedralView view);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3SoftBodyDesc_SetWire(struct R3SoftBodyDesc *desc,
                                      struct R3EdgeView view);
#endif

RAPIER_API
struct R3ColliderDesc RAPIER_CALL r3RoundCuboidColliderDesc(struct R3Vector half_extents,
                                                      R3Real border_radius);

RAPIER_API
struct R3ColliderDesc RAPIER_CALL r3CapsuleColliderDesc(struct R3Vector a,
                                                 struct R3Vector b,
                                                 R3Real radius);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3SegmentColliderDesc(struct R3Vector a, struct R3Vector b);

RAPIER_API
struct R3ColliderDesc RAPIER_CALL r3TriangleColliderDesc(struct R3Vector a,
                                                  struct R3Vector b,
                                                  struct R3Vector c);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3HalfspaceColliderDesc(struct R3Vector normal);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3ColliderDesc RAPIER_CALL r3CylinderColliderDesc(R3Real half_height, R3Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3ColliderDesc RAPIER_CALL r3ConeColliderDesc(R3Real half_height, R3Real radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3ColliderDesc RAPIER_CALL r3RoundCylinderColliderDesc(R3Real half_height,
                                                        R3Real radius,
                                                        R3Real border_radius);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3ColliderDesc RAPIER_CALL r3RoundConeColliderDesc(R3Real half_height,
                                                    R3Real radius,
                                                    R3Real border_radius);
#endif

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3CapsuleXColliderDesc(R3Real half_height, R3Real radius);

RAPIER_API struct R3ColliderDesc RAPIER_CALL r3CapsuleYColliderDesc(R3Real half_height, R3Real radius);
 
#if defined(RAPIER_DIM3)
RAPIER_API struct R3ColliderDesc RAPIER_CALL r3CapsuleZColliderDesc(R3Real half_height, R3Real radius);
#endif

RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3RopeSoftBodyDesc(struct R3Vector a,
                                               struct R3Vector b,
                                               size_t particles);
 
#if defined(RAPIER_DIM2)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3GridSoftBodyDesc(struct R3Vector center,
                                               struct R3Vector half_extents,
                                               size_t nx,
                                               size_t ny);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3CuboidSoftBodyDesc(struct R3Vector center,
                                                 struct R3Vector half_extents,
                                                 size_t nx,
                                                 size_t ny,
                                                 size_t nz);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3ClothSoftBodyDesc(struct R3Vector origin,
                                                struct R3Vector du,
                                                struct R3Vector dv,
                                                size_t nu,
                                                size_t nv);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3ClothAnisotropicSoftBodyDesc(struct R3Vector origin,
                                                            struct R3Vector du,
                                                            struct R3Vector dv,
                                                            size_t nu,
                                                            size_t nv,
                                                            struct R3SpringCoefficients warp,
                                                            struct R3SpringCoefficients weft,
                                                            struct R3SpringCoefficients shear);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API struct R3SoftBodyDesc RAPIER_CALL r3PolygonSoftBodyDesc(struct R3VectorView points);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3DiskSoftBodyDesc(struct R3Vector center,
                                               R3Real radius,
                                               size_t particles);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3SphereSoftBodyDesc(struct R3Vector center,
                                                 R3Real radius,
                                                 uint32_t subdivisions);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3ClothTubeSoftBodyDesc(struct R3Vector origin,
                                                     struct R3Vector axis,
                                                     R3Real radius_start,
                                                     R3Real radius_end,
                                                     size_t num_around,
                                                     size_t num_along);
#endif

RAPIER_API
struct R3SoftBodyDesc RAPIER_CALL r3VolumetricSoftBodyDesc(struct R3VectorView vertices,
                                                     R3SurfaceElementView surface,
                                                     struct R3VolumeMeshParameters parameters);

RAPIER_API
struct R3SoftBodyMaterial RAPIER_CALL r3UniformSoftBodyMaterial(struct R3SpringCoefficients value);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyDesc_ParticlePositions(const struct R3SoftBodyDesc *desc,
                                             struct R3Vector *buffer,
                                             size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBodyDesc_CellIndices(const struct R3SoftBodyDesc *desc,
                                       uint32_t *buffer,
                                       size_t capacity);

RAPIER_API
struct R3Vector RAPIER_CALL r3SoftBody_ParticleVelocity(struct R3SoftBodyHandle handle,
                                                 size_t index);

RAPIER_API uint32_t RAPIER_CALL r3SoftBody_Solver(struct R3SoftBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterEdgeSoftness(struct R3SoftBodyHandle handle,
                                                  uint32_t cluster,
                                                  const struct R3SpringCoefficients *softness);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_ApplyImpulseAtPoint(struct R3SoftBodyHandle handle,
                                               struct R3Vector impulse,
                                               struct R3Vector point,
                                               R3Real falloff_radius,
                                               R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_ApplyRadialImpulse(struct R3SoftBodyHandle handle,
                                             struct R3Vector center,
                                             R3Real magnitude,
                                             R3Real falloff_radius,
                                             R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_ResetPlasticity(struct R3SoftBodyHandle handle);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_TearEdge(struct R3SoftBodyHandle handle, size_t index);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_TearCell(struct R3SoftBodyHandle handle, size_t index);

RAPIER_API struct R3SoftBodyHandle RAPIER_CALL r3Collider_SoftBody(struct R3ColliderHandle handle);

RAPIER_API
struct R3SoftBodyHandle RAPIER_CALL r3ReadCollider_SoftBody(const struct R3ReadContext *context,
                                                     struct R3ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r3SoftBodyTearEvent_PieceCount(const struct R3SoftBodyTearEvent *event);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryAuthoredVelocityMargin(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryEdgeSpeculation(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryInvertedCellDetection(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoverySelfCrossingDetection(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryDetectionMotionGating(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryCrossBodyDetection(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoverySelfStandDown(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryCrossBodyExpelGate(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryEdgeStandDown(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryCrossingRepulsion(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryCrossingRepulsionGuide(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryCrossingRepulsionSelfGuide(const struct R3World *world);

RAPIER_API R3Real RAPIER_CALL r3RecoveryRecoveryPace(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapConstraints(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapRigid(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapSkipSelfTangled(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapEdgeStandDown(const struct R3World *world);

RAPIER_API R3Real RAPIER_CALL r3RecoveryOverlapConstraintPace(const struct R3World *world);

RAPIER_API uint32_t RAPIER_CALL r3RecoveryOverlapPatchConstraints(const struct R3World *world);

RAPIER_API
R3Status RAPIER_CALL r3RecoverySetOverlapPatchConstraints(struct R3World *world,
                                                     uint32_t value);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapSkinVolume(const struct R3World *world);

RAPIER_API R3Real RAPIER_CALL r3RecoveryOverlapKeptDepth(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapSelfRegions(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapNormalPush(const struct R3World *world);

RAPIER_API R3Bool RAPIER_CALL r3RecoveryOverlapMultiVolume(const struct R3World *world);

RAPIER_API uint32_t RAPIER_CALL r3RecoveryOverlapSplit(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapSplit(struct R3World *world, uint32_t value);

RAPIER_API uint32_t RAPIER_CALL r3RecoveryOverlapPatience(const struct R3World *world);

RAPIER_API R3Status RAPIER_CALL r3RecoverySetOverlapPatience(struct R3World *world, uint32_t value);

RAPIER_API R3Real RAPIER_CALL r3RecoveryOverlapProgressMargin(const struct R3World *world);
 
#if defined(RAPIER_FEM)
RAPIER_API R3Real RAPIER_CALL r3FemLinearTolerance(const struct R3World *world);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API size_t RAPIER_CALL r3FemMaxLinearIterations(const struct R3World *world);
#endif
 
#if defined(RAPIER_FEM)
RAPIER_API size_t RAPIER_CALL r3FemMaxDenseDofs(const struct R3World *world);
#endif

RAPIER_API size_t RAPIER_CALL r3Collider_ShapeIdentity(struct R3ColliderHandle handle);

RAPIER_API size_t RAPIER_CALL r3SoftBody_NumParticles(struct R3SoftBodyHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3SoftBody_TopologyVersion(struct R3SoftBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3SoftBody_Mass(struct R3SoftBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3SoftBody_Volume(struct R3SoftBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3SoftBody_RestVolume(struct R3SoftBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3SoftBody_VolumeFactor(struct R3SoftBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3SoftBody_CenterOfMass(struct R3SoftBodyHandle handle);

RAPIER_API struct R3RigidBodyHandle RAPIER_CALL r3SoftBody_RootBody(struct R3SoftBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3SoftBody_IsEnabled(struct R3SoftBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3SoftBody_IsSleeping(struct R3SoftBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_ParticleVelocities(struct R3SoftBodyHandle handle,
                                         struct R3Vector *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Edges(struct R3SoftBodyHandle handle,
                           uint32_t *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Cells(struct R3SoftBodyHandle handle,
                           uint32_t *buffer,
                           size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Boundary(struct R3SoftBodyHandle handle,
                              uint32_t *buffer,
                              size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Pieces(struct R3SoftBodyHandle handle,
                            struct R3SoftBodyHandle *buffer,
                            size_t capacity);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetParticleVelocity(struct R3SoftBodyHandle handle,
                                              size_t index,
                                              struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetParticleKinematicTarget(struct R3SoftBodyHandle handle,
                                                      size_t index,
                                                      struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetParticlePinned(struct R3SoftBodyHandle handle,
                                            size_t index,
                                            R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_ApplyParticleImpulse(struct R3SoftBodyHandle handle,
                                               size_t index,
                                               struct R3Vector value,
                                               R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_AddForce(struct R3SoftBodyHandle handle,
                                  struct R3Vector value,
                                  R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_ApplyImpulse(struct R3SoftBodyHandle handle,
                                      struct R3Vector value,
                                      R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_ResetForces(struct R3SoftBodyHandle handle, R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_SetEnabled(struct R3SoftBodyHandle handle, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetVolumeFactor(struct R3SoftBodyHandle handle,
                                          R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_AttachParticle(struct R3SoftBodyHandle handle,
                                        size_t index,
                                        struct R3RigidBodyHandle rigid_body);

RAPIER_API R3Bool RAPIER_CALL r3SoftBody_DetachParticle(struct R3SoftBodyHandle handle, size_t index);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Clusters(struct R3SoftBodyHandle handle,
                              uint32_t *buffer,
                              size_t capacity);

RAPIER_API
struct R3RigidBodyHandle RAPIER_CALL r3SoftBody_ClusterProxy(struct R3SoftBodyHandle handle,
                                                      uint32_t cluster);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_ClusterParticles(struct R3SoftBodyHandle handle,
                                       uint32_t cluster,
                                       uint32_t *buffer,
                                       size_t capacity);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterPinned(struct R3SoftBodyHandle handle,
                                           uint32_t cluster,
                                           R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterKinematicTarget(struct R3SoftBodyHandle handle,
                                                     uint32_t cluster,
                                                     struct R3Pose value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterShapeMatchingEnabled(struct R3SoftBodyHandle handle,
                                                           uint32_t cluster,
                                                           R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterStiffnessScale(struct R3SoftBodyHandle handle,
                                                    uint32_t cluster,
                                                    R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterTearResistance(struct R3SoftBodyHandle handle,
                                                    uint32_t cluster,
                                                    R3Real value);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_Meshes(struct R3SoftBodyHandle handle,
                            struct R3SoftMeshInfo *buffer,
                            size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshVerticesById(struct R3SoftBodyHandle handle,
                                         struct R3SoftMeshId id,
                                         struct R3Vector *buffer,
                                         size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshIndicesById(struct R3SoftBodyHandle handle,
                                        struct R3SoftMeshId id,
                                        uint32_t *buffer,
                                        size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshColliders(struct R3SoftBodyHandle handle,
                                    struct R3ColliderHandle *buffer,
                                    size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshVertices(struct R3SoftBodyHandle handle,
                                   struct R3ColliderHandle collider,
                                   struct R3Vector *buffer,
                                   size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshIndices(struct R3SoftBodyHandle handle,
                                  struct R3ColliderHandle collider,
                                  uint32_t *buffer,
                                  size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SoftBody_MeshArity(struct R3SoftBodyHandle handle,
                                struct R3ColliderHandle collider);

RAPIER_API
uint32_t RAPIER_CALL r3SoftBody_MeshTopologyVersion(struct R3SoftBodyHandle handle,
                                             struct R3ColliderHandle collider);
 
#if defined(RAPIER_FEM)
RAPIER_API R3Status RAPIER_CALL r3SoftBody_SetSolver(struct R3SoftBodyHandle handle, uint32_t solver);
#endif

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetClusterShapeMatchingTarget(struct R3SoftBodyHandle handle,
                                                          uint32_t cluster,
                                                          const struct R3Pose *target);

RAPIER_API
R3Status RAPIER_CALL r3SoftBody_SetEdgeTearResistance(struct R3SoftBodyHandle handle,
                                                 size_t index,
                                                 R3Real resistance);

RAPIER_API
R3Bool RAPIER_CALL r3SoftBody_MeshIsClosed(struct R3SoftBodyHandle handle,
                                     struct R3ColliderHandle collider);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAdditionalMassProperties(struct R3RigidBodyHandle handle,
                                                        struct R3MassProperties properties,
                                                        R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_RecomputeMassPropertiesFromColliders(struct R3RigidBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetMassProperties(struct R3ColliderHandle handle,
                                           struct R3MassProperties properties);

RAPIER_API struct R3MassProperties RAPIER_CALL r3Collider_MassProperties(struct R3ColliderHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetLockedAxes(struct R3RigidBodyHandle handle,
                                         uint8_t axes,
                                         R3Bool wake_up);

RAPIER_API uint8_t RAPIER_CALL r3RigidBody_LockedAxes(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3Collider_IsVoxels(struct R3ColliderHandle handle);

RAPIER_API
struct R3VoxelQuery RAPIER_CALL r3Collider_VoxelAtFlatId(struct R3ColliderHandle handle,
                                                   uint32_t id);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetVoxel(struct R3ColliderHandle handle,
                                 struct R3VoxelKey key,
                                 R3Bool filled);

RAPIER_API struct R3Pose RAPIER_CALL r3RigidBody_NextPosition(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Rotation RAPIER_CALL r3RigidBody_Rotation(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3RigidBody_CenterOfMass(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3RigidBody_LocalCenterOfMass(struct R3RigidBodyHandle handle);

RAPIER_API struct R3Vector RAPIER_CALL r3RigidBody_UserForce(struct R3RigidBodyHandle handle);

RAPIER_API R3AngVector RAPIER_CALL r3RigidBody_UserTorque(struct R3RigidBodyHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3RigidBody_BodyType(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_Mass(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_GravityScale(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_LinearDamping(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_AngularDamping(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_KineticEnergy(struct R3RigidBodyHandle handle);

RAPIER_API R3Real RAPIER_CALL r3RigidBody_SoftCcdPrediction(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsCcdEnabled(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsDynamic(struct R3RigidBodyHandle handle);

RAPIER_API struct R3SoftBodyHandle RAPIER_CALL r3RigidBody_SoftBody(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsSoftFrame(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsFixed(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsKinematic(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsMoving(struct R3RigidBodyHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3RigidBody_IsCcdActive(struct R3RigidBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetRotation(struct R3RigidBodyHandle handle,
                                      struct R3Rotation value,
                                      R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetBodyType(struct R3RigidBodyHandle handle,
                                       uint32_t value,
                                       R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetNextKinematicRotation(struct R3RigidBodyHandle handle,
                                                     struct R3Rotation value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAdditionalMass(struct R3RigidBodyHandle handle,
                                             R3Real value,
                                             R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetSoftCcdPrediction(struct R3RigidBodyHandle handle,
                                                 R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetCcdEnabled(struct R3RigidBodyHandle handle,
                                         R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetTranslationsLocked(struct R3RigidBodyHandle handle,
                                                 R3Bool value,
                                                 R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetRotationsLocked(struct R3RigidBodyHandle handle,
                                              R3Bool value,
                                              R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetDominanceGroup(struct R3RigidBodyHandle handle,
                                             int8_t value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAdditionalSolverIterations(struct R3RigidBodyHandle handle,
                                                          size_t value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetAdditionalPgsIterations(struct R3RigidBodyHandle handle,
                                                       size_t value);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_AddTorque(struct R3RigidBodyHandle handle,
                                    R3AngVector value,
                                    R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_ApplyTorqueImpulse(struct R3RigidBodyHandle handle,
                                              R3AngVector value,
                                              R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_AddForceAtPoint(struct R3RigidBodyHandle handle,
                                            struct R3Vector value,
                                            struct R3Vector point,
                                            R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3RigidBody_ResetTorques(struct R3RigidBodyHandle handle,
                                       R3Bool wake_up);

RAPIER_API
struct R3Vector RAPIER_CALL r3RigidBody_VelocityAtPoint(struct R3RigidBodyHandle handle,
                                                  struct R3Vector point);

RAPIER_API
size_t RAPIER_CALL r3RigidBody_Colliders(struct R3RigidBodyHandle handle,
                                struct R3ColliderHandle *buffer,
                                size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API R3Bool RAPIER_CALL r3RigidBody_GyroscopicForcesEnabled(struct R3RigidBodyHandle handle);
#endif
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Status RAPIER_CALL r3RigidBody_SetGyroscopicForcesEnabled(struct R3RigidBodyHandle handle,
                                                       R3Bool enabled);
#endif

RAPIER_API R3Status RAPIER_CALL r3Collider_SetDensity(struct R3ColliderHandle handle, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetMass(struct R3ColliderHandle handle, R3Real value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetEnabled(struct R3ColliderHandle handle, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetSolverGroups(struct R3ColliderHandle handle,
                                         struct R3InteractionGroups value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetFrictionCombineRule(struct R3ColliderHandle handle,
                                                 uint32_t value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetRestitutionCombineRule(struct R3ColliderHandle handle,
                                                    uint32_t value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetContactSkin(struct R3ColliderHandle handle, R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetContactForceEventThreshold(struct R3ColliderHandle handle,
                                                         R3Real value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetActiveEvents(struct R3ColliderHandle handle,
                                         uint32_t value);

RAPIER_API R3Status RAPIER_CALL r3Collider_SetActiveHooks(struct R3ColliderHandle handle, uint32_t value);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetActiveCollisionTypes(struct R3ColliderHandle handle,
                                                  uint16_t value);

RAPIER_API struct R3Rotation RAPIER_CALL r3Collider_Rotation(struct R3ColliderHandle handle);

RAPIER_API
struct R3InteractionGroups RAPIER_CALL r3Collider_CollisionGroups(struct R3ColliderHandle handle);

RAPIER_API struct R3InteractionGroups RAPIER_CALL r3Collider_SolverGroups(struct R3ColliderHandle handle);

RAPIER_API struct R3UserData RAPIER_CALL r3Collider_UserData(struct R3ColliderHandle handle);

RAPIER_API uint32_t RAPIER_CALL r3Collider_ActiveEvents(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_Mass(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_Density(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_Volume(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_ContactSkin(struct R3ColliderHandle handle);

RAPIER_API R3Real RAPIER_CALL r3Collider_ContactForceEventThreshold(struct R3ColliderHandle handle);

RAPIER_API R3Bool RAPIER_CALL r3Collider_IsEnabled(struct R3ColliderHandle handle);

RAPIER_API struct R3Aabb RAPIER_CALL r3Collider_ComputeAabb(struct R3ColliderHandle handle);

RAPIER_API R3SharedShape *RAPIER_CALL r3Collider_CloneShape(struct R3ColliderHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetShape(struct R3ColliderHandle handle,
                                 const R3SharedShape *shape);

RAPIER_API
R3Status RAPIER_CALL r3Collider_SetPositionWrtParent(struct R3ColliderHandle handle,
                                               struct R3Pose value);

RAPIER_API R3Status RAPIER_CALL r3RigidBody_ValidateHandle(struct R3RigidBodyHandle handle);

RAPIER_API R3Status RAPIER_CALL r3Collider_ValidateHandle(struct R3ColliderHandle handle);

RAPIER_API R3Status RAPIER_CALL r3SoftBody_ValidateHandle(struct R3SoftBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalFrame1(struct R3JointDesc *desc,
                                          struct R3Pose value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalFrame1(struct R3ImpulseJointHandle handle,
                                             struct R3Pose value,
                                             R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalFrame2(struct R3JointDesc *desc,
                                          struct R3Pose value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalFrame2(struct R3ImpulseJointHandle handle,
                                             struct R3Pose value,
                                             R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalAnchor1(struct R3JointDesc *desc,
                                           struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalAnchor1(struct R3ImpulseJointHandle handle,
                                              struct R3Vector value,
                                              R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalAnchor2(struct R3JointDesc *desc,
                                           struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalAnchor2(struct R3ImpulseJointHandle handle,
                                              struct R3Vector value,
                                              R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetContactsEnabled(struct R3JointDesc *desc, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetContactsEnabled(struct R3ImpulseJointHandle handle,
                                                 R3Bool value,
                                                 R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetEnabled(struct R3JointDesc *desc, R3Bool value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetEnabled(struct R3ImpulseJointHandle handle,
                                        R3Bool value,
                                        R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetSoftness(struct R3JointDesc *desc,
                                      struct R3SpringCoefficients value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetSoftness(struct R3ImpulseJointHandle handle,
                                         struct R3SpringCoefficients value,
                                         R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetLockedAxes(struct R3JointDesc *desc, uint8_t value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLockedAxes(struct R3ImpulseJointHandle handle,
                                            uint8_t value,
                                            R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetLimitAxes(struct R3JointDesc *desc, uint8_t value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLimitAxes(struct R3ImpulseJointHandle handle,
                                           uint8_t value,
                                           R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetMotorAxes(struct R3JointDesc *desc, uint8_t value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotorAxes(struct R3ImpulseJointHandle handle,
                                           uint8_t value,
                                           R3Bool wake_up);

RAPIER_API R3Status RAPIER_CALL r3JointDesc_SetCoupledAxes(struct R3JointDesc *desc, uint8_t value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetCoupledAxes(struct R3ImpulseJointHandle handle,
                                             uint8_t value,
                                             R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalAxis1(struct R3JointDesc *desc,
                                         struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalAxis1(struct R3ImpulseJointHandle handle,
                                            struct R3Vector value,
                                            R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLocalAxis2(struct R3JointDesc *desc,
                                         struct R3Vector value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLocalAxis2(struct R3ImpulseJointHandle handle,
                                            struct R3Vector value,
                                            R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetLimits(struct R3JointDesc *desc,
                                    uint32_t joint_axis,
                                    R3Real min,
                                    R3Real max);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetLimits(struct R3ImpulseJointHandle handle,
                                       uint32_t joint_axis,
                                       R3Real min,
                                       R3Real max,
                                       R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetMotor(struct R3JointDesc *desc,
                                   uint32_t joint_axis,
                                   R3Real target_position,
                                   R3Real target_velocity,
                                   R3Real stiffness,
                                   R3Real damping);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotor(struct R3ImpulseJointHandle handle,
                                      uint32_t joint_axis,
                                      R3Real target_position,
                                      R3Real target_velocity,
                                      R3Real stiffness,
                                      R3Real damping,
                                      R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetMotorMaxForce(struct R3JointDesc *desc,
                                             uint32_t joint_axis,
                                             R3Real max_force);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotorMaxForce(struct R3ImpulseJointHandle handle,
                                                uint32_t joint_axis,
                                                R3Real max_force,
                                                R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetMotorModel(struct R3JointDesc *desc,
                                         uint32_t joint_axis,
                                         uint32_t model);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotorModel(struct R3ImpulseJointHandle handle,
                                            uint32_t joint_axis,
                                            uint32_t model,
                                            R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetUserData(struct R3JointDesc *desc,
                                       struct R3UserData value);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetUserData(struct R3ImpulseJointHandle handle,
                                          struct R3UserData value,
                                          R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetMotorPosition(struct R3JointDesc *desc,
                                            uint32_t joint_axis,
                                            R3Real target_position,
                                            R3Real stiffness,
                                            R3Real damping);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotorPosition(struct R3ImpulseJointHandle handle,
                                               uint32_t joint_axis,
                                               R3Real target_position,
                                               R3Real stiffness,
                                               R3Real damping,
                                               R3Bool wake_up);

RAPIER_API
R3Status RAPIER_CALL r3JointDesc_SetMotorVelocity(struct R3JointDesc *desc,
                                            uint32_t joint_axis,
                                            R3Real target_velocity,
                                            R3Real factor);

RAPIER_API
R3Status RAPIER_CALL r3ImpulseJoint_SetMotorVelocity(struct R3ImpulseJointHandle handle,
                                               uint32_t joint_axis,
                                               R3Real target_velocity,
                                               R3Real factor,
                                               R3Bool wake_up);

RAPIER_API struct R3JointImpulses RAPIER_CALL r3ImpulseJoint_Impulses(struct R3ImpulseJointHandle handle);

RAPIER_API struct R3UserData RAPIER_CALL r3ImpulseJoint_UserData(struct R3ImpulseJointHandle handle);

RAPIER_API size_t RAPIER_CALL r3ImpulseJointCount(const struct R3World *world);

RAPIER_API size_t RAPIER_CALL r3MultibodyJointCount(const struct R3World *world);

RAPIER_API struct R3JointDesc RAPIER_CALL r3MultibodyJoint_Desc(struct R3MultibodyJointHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3MultibodyJoint_SetDesc(struct R3MultibodyJointHandle handle,
                                       const struct R3JointDesc *desc,
                                       R3Bool wake_up);

RAPIER_API struct R3JointBodies RAPIER_CALL r3MultibodyJoint_Bodies(struct R3MultibodyJointHandle handle);

RAPIER_API
R3SharedShape *RAPIER_CALL r3ConvexDecompositionSharedShape(struct R3VectorView vertices,
                                                      R3SurfaceElementView indices);

RAPIER_API
R3SharedShape *RAPIER_CALL r3VoxelsSharedShapeFromPoints(struct R3Vector voxel_size,
                                                    struct R3VectorView points);

RAPIER_API
R3SharedShape *RAPIER_CALL r3VoxelizedMeshSharedShape(struct R3VectorView vertices,
                                                R3SurfaceElementView indices,
                                                R3Real voxel_size);

RAPIER_API R3SharedShape *RAPIER_CALL r3ConvexHullSharedShape(struct R3VectorView vertices);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3SharedShape *RAPIER_CALL r3ConvexMeshSharedShape(struct R3VectorView vertices,
                                             struct R3TriangleView indices);
#endif

RAPIER_API
R3SharedShape *RAPIER_CALL r3TrimeshSharedShape(struct R3VectorView vertices,
                                         struct R3TriangleView indices);

RAPIER_API
R3SharedShape *RAPIER_CALL r3PolylineSharedShape(struct R3VectorView vertices,
                                          struct R3EdgeView indices);
 
#if defined(RAPIER_DIM2)
RAPIER_API
R3SharedShape *RAPIER_CALL r3OrientedPolylineSharedShape(struct R3VectorView vertices,
                                                   struct R3EdgeView indices);
#endif
 
#if defined(RAPIER_DIM2)
RAPIER_API R3SharedShape *RAPIER_CALL r3ConvexPolylineSharedShape(struct R3VectorView vertices);
#endif

RAPIER_API
R3SharedShape *RAPIER_CALL r3RoundConvexHullSharedShape(struct R3VectorView vertices,
                                                   R3Real border_radius);

RAPIER_API
R3SharedShape *RAPIER_CALL r3TrimeshSharedShapeWithFlags(struct R3VectorView vertices,
                                                    struct R3TriangleView indices,
                                                    uint32_t flags);

RAPIER_API struct R3World *RAPIER_CALL r3NewWorld(void);

RAPIER_API R3Status RAPIER_CALL r3FreeWorld(struct R3World *world);

RAPIER_API
struct R3VelocityCorrection RAPIER_CALL r3ReadPidController_RigidBodyCorrection(const struct R3ReadContext *context,
                                                                           struct R3PidController *controller,
                                                                           R3Real dt,
                                                                           struct R3RigidBodyHandle body,
                                                                           struct R3Pose target_pose,
                                                                           struct R3Vector target_linvel,
                                                                           R3AngVector target_angvel);

RAPIER_API
struct R3VelocityCorrection RAPIER_CALL r3ReadPdController_RigidBodyCorrection(const struct R3ReadContext *context,
                                                                          const struct R3PdController *controller,
                                                                          struct R3RigidBodyHandle body,
                                                                          struct R3Pose target_pose,
                                                                          struct R3Vector target_linvel,
                                                                          R3AngVector target_angvel);

RAPIER_API size_t RAPIER_CALL r3ReadRigidBodyCount(const struct R3ReadContext *context);

RAPIER_API
size_t RAPIER_CALL r3ReadRigidBodyHandles(const struct R3ReadContext *context,
                                   struct R3RigidBodyHandle *buffer,
                                   size_t capacity);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_Contains(const struct R3ReadContext *context,
                                     struct R3RigidBodyHandle handle);

RAPIER_API size_t RAPIER_CALL r3ReadColliderCount(const struct R3ReadContext *context);

RAPIER_API
size_t RAPIER_CALL r3ReadColliderHandles(const struct R3ReadContext *context,
                                 struct R3ColliderHandle *buffer,
                                 size_t capacity);

RAPIER_API
R3Bool RAPIER_CALL r3ReadCollider_Contains(const struct R3ReadContext *context,
                                   struct R3ColliderHandle handle);

RAPIER_API
size_t RAPIER_CALL r3ReadCollider_ShapeIdentity(const struct R3ReadContext *context,
                                        struct R3ColliderHandle handle);

RAPIER_API
struct R3MassProperties RAPIER_CALL r3ReadCollider_MassProperties(const struct R3ReadContext *context,
                                                           struct R3ColliderHandle handle);

RAPIER_API
uint8_t RAPIER_CALL r3ReadRigidBody_LockedAxes(const struct R3ReadContext *context,
                                        struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadCollider_IsVoxels(const struct R3ReadContext *context,
                                    struct R3ColliderHandle handle);

RAPIER_API
struct R3VoxelQuery RAPIER_CALL r3ReadCollider_VoxelAtFlatId(const struct R3ReadContext *context,
                                                        struct R3ColliderHandle handle,
                                                        uint32_t id);

RAPIER_API
struct R3Pose RAPIER_CALL r3ReadRigidBody_NextPosition(const struct R3ReadContext *context,
                                                 struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Rotation RAPIER_CALL r3ReadRigidBody_Rotation(const struct R3ReadContext *context,
                                                struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_CenterOfMass(const struct R3ReadContext *context,
                                                    struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_LocalCenterOfMass(const struct R3ReadContext *context,
                                                          struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_UserForce(const struct R3ReadContext *context,
                                                struct R3RigidBodyHandle handle);

RAPIER_API
R3AngVector RAPIER_CALL r3ReadRigidBody_UserTorque(const struct R3ReadContext *context,
                                             struct R3RigidBodyHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r3ReadRigidBody_BodyType(const struct R3ReadContext *context,
                                       struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_Mass(const struct R3ReadContext *context,
                                 struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_GravityScale(const struct R3ReadContext *context,
                                          struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_LinearDamping(const struct R3ReadContext *context,
                                           struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_AngularDamping(const struct R3ReadContext *context,
                                            struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_KineticEnergy(const struct R3ReadContext *context,
                                           struct R3RigidBodyHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadRigidBody_SoftCcdPrediction(const struct R3ReadContext *context,
                                                struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsCcdEnabled(const struct R3ReadContext *context,
                                           struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsDynamic(const struct R3ReadContext *context,
                                       struct R3RigidBodyHandle handle);

RAPIER_API
struct R3SoftBodyHandle RAPIER_CALL r3ReadRigidBody_SoftBody(const struct R3ReadContext *context,
                                                       struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsSoftFrame(const struct R3ReadContext *context,
                                          struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsFixed(const struct R3ReadContext *context,
                                     struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsKinematic(const struct R3ReadContext *context,
                                         struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsMoving(const struct R3ReadContext *context,
                                      struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsCcdActive(const struct R3ReadContext *context,
                                          struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_VelocityAtPoint(const struct R3ReadContext *context,
                                                       struct R3RigidBodyHandle handle,
                                                       struct R3Vector point);

RAPIER_API
size_t RAPIER_CALL r3ReadRigidBody_Colliders(const struct R3ReadContext *context,
                                     struct R3RigidBodyHandle handle,
                                     struct R3ColliderHandle *buffer,
                                     size_t capacity);
 
#if defined(RAPIER_DIM3)
RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_GyroscopicForcesEnabled(const struct R3ReadContext *context,
                                                      struct R3RigidBodyHandle handle);
#endif

RAPIER_API
struct R3Rotation RAPIER_CALL r3ReadCollider_Rotation(const struct R3ReadContext *context,
                                              struct R3ColliderHandle handle);

RAPIER_API
struct R3InteractionGroups RAPIER_CALL r3ReadCollider_CollisionGroups(const struct R3ReadContext *context,
                                                               struct R3ColliderHandle handle);

RAPIER_API
struct R3InteractionGroups RAPIER_CALL r3ReadCollider_SolverGroups(const struct R3ReadContext *context,
                                                            struct R3ColliderHandle handle);

RAPIER_API
struct R3UserData RAPIER_CALL r3ReadCollider_UserData(const struct R3ReadContext *context,
                                               struct R3ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r3ReadCollider_ActiveEvents(const struct R3ReadContext *context,
                                         struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_Mass(const struct R3ReadContext *context,
                               struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_Density(const struct R3ReadContext *context,
                                  struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_Volume(const struct R3ReadContext *context,
                                 struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_ContactSkin(const struct R3ReadContext *context,
                                       struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_ContactForceEventThreshold(const struct R3ReadContext *context,
                                                        struct R3ColliderHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadCollider_IsEnabled(const struct R3ReadContext *context,
                                     struct R3ColliderHandle handle);

RAPIER_API
struct R3Aabb RAPIER_CALL r3ReadCollider_ComputeAabb(const struct R3ReadContext *context,
                                              struct R3ColliderHandle handle);

RAPIER_API
R3SharedShape *RAPIER_CALL r3ReadCollider_CloneShape(const struct R3ReadContext *context,
                                              struct R3ColliderHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3ReadRigidBody_ValidateHandle(const struct R3ReadContext *context,
                                              struct R3RigidBodyHandle handle);

RAPIER_API
R3Status RAPIER_CALL r3ReadCollider_ValidateHandle(const struct R3ReadContext *context,
                                            struct R3ColliderHandle handle);

RAPIER_API
struct R3Pose RAPIER_CALL r3ReadRigidBody_Position(const struct R3ReadContext *context,
                                            struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_Translation(const struct R3ReadContext *context,
                                                 struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadRigidBody_Linvel(const struct R3ReadContext *context,
                                            struct R3RigidBodyHandle handle);

RAPIER_API
R3AngVector RAPIER_CALL r3ReadRigidBody_Angvel(const struct R3ReadContext *context,
                                        struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsSleeping(const struct R3ReadContext *context,
                                        struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsEnabled(const struct R3ReadContext *context,
                                       struct R3RigidBodyHandle handle);

RAPIER_API
struct R3UserData RAPIER_CALL r3ReadRigidBody_UserData(const struct R3ReadContext *context,
                                                 struct R3RigidBodyHandle handle);

RAPIER_API
struct R3Pose RAPIER_CALL r3ReadCollider_Position(const struct R3ReadContext *context,
                                          struct R3ColliderHandle handle);

RAPIER_API
struct R3Vector RAPIER_CALL r3ReadCollider_Translation(const struct R3ReadContext *context,
                                               struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_Friction(const struct R3ReadContext *context,
                                   struct R3ColliderHandle handle);

RAPIER_API
R3Real RAPIER_CALL r3ReadCollider_Restitution(const struct R3ReadContext *context,
                                      struct R3ColliderHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadCollider_IsSensor(const struct R3ReadContext *context,
                                    struct R3ColliderHandle handle);

RAPIER_API
struct R3RigidBodyHandle RAPIER_CALL r3ReadCollider_Parent(const struct R3ReadContext *context,
                                                   struct R3ColliderHandle handle);

RAPIER_API
size_t RAPIER_CALL r3ReadRigidBodyReadStates(const struct R3ReadContext *context,
                                       const struct R3RigidBodyHandle *handles,
                                       size_t handle_count,
                                       struct R3RigidBodyState *states,
                                       size_t capacity);

RAPIER_API
uint16_t RAPIER_CALL r3ReadCollider_ActiveCollisionTypes(const struct R3ReadContext *context,
                                                  struct R3ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r3ReadCollider_ActiveHooks(const struct R3ReadContext *context,
                                        struct R3ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r3ReadCollider_FrictionCombineRule(const struct R3ReadContext *context,
                                                 struct R3ColliderHandle handle);

RAPIER_API
uint32_t RAPIER_CALL r3ReadCollider_RestitutionCombineRule(const struct R3ReadContext *context,
                                                    struct R3ColliderHandle handle);

RAPIER_API
struct R3Pose RAPIER_CALL r3ReadCollider_PositionWrtParent(const struct R3ReadContext *context,
                                                     struct R3ColliderHandle handle);

RAPIER_API
int8_t RAPIER_CALL r3ReadRigidBody_DominanceGroup(const struct R3ReadContext *context,
                                           struct R3RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r3ReadRigidBody_AdditionalSolverIterations(const struct R3ReadContext *context,
                                                        struct R3RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r3ReadRigidBody_AdditionalPgsIterations(const struct R3ReadContext *context,
                                                     struct R3RigidBodyHandle handle);

RAPIER_API
R3Bool RAPIER_CALL r3ReadRigidBody_IsFastRotationAllowed(const struct R3ReadContext *context,
                                                     struct R3RigidBodyHandle handle);

RAPIER_API
size_t RAPIER_CALL r3IntersectRay(const struct R3World *world,
                         const struct R3QueryOptions *query_options,
                         struct R3Vector origin,
                         struct R3Vector direction,
                         R3Real max_toi,
                         R3Bool solid,
                         struct R3RayHit *buffer,
                         size_t capacity);

RAPIER_API
struct R3OptionalShapeCastHit RAPIER_CALL r3TryCastShape(const struct R3World *world,
                                                  const struct R3QueryOptions *query_options,
                                                  struct R3Pose pose,
                                                  struct R3Vector velocity,
                                                  const R3SharedShape *shape,
                                                  struct R3ShapeCastOptions options);

RAPIER_API
struct R3OptionalPointProjection RAPIER_CALL r3TryProjectPoint(const struct R3World *world,
                                                        const struct R3QueryOptions *query_options,
                                                        struct R3Vector point,
                                                        R3Real max_distance,
                                                        R3Bool solid);

RAPIER_API
struct R3Pose RAPIER_CALL r3NonlinearRigidMotion_PositionAtTime(const struct R3NonlinearRigidMotion *motion,
                                                           R3Real time);

RAPIER_API
struct R3OptionalShapeCastHit RAPIER_CALL r3TryCastShapeNonlinear(const struct R3World *world,
                                                            const struct R3QueryOptions *query_options,
                                                            const struct R3NonlinearRigidMotion *motion,
                                                            const R3SharedShape *shape,
                                                            R3Real start_time,
                                                            R3Real end_time,
                                                            R3Bool stop_at_penetration);

RAPIER_API
struct R3OptionalContactPair RAPIER_CALL r3TryContactPair(struct R3ColliderHandle collider1,
                                                   struct R3ColliderHandle collider2);

RAPIER_API
struct R3IntersectionPair RAPIER_CALL r3IntersectionPair(struct R3ColliderHandle collider1,
                                                 struct R3ColliderHandle collider2);

RAPIER_API
struct R3OptionalIntersectionPair RAPIER_CALL r3TryIntersectionPair(struct R3ColliderHandle collider1,
                                                             struct R3ColliderHandle collider2);

RAPIER_API
size_t RAPIER_CALL r3Collider_ContactPairs(struct R3ColliderHandle handle,
                                  struct R3ContactPair *buffer,
                                  size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3Collider_IntersectionPairs(struct R3ColliderHandle handle,
                                       struct R3IntersectionPair *buffer,
                                       size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3ContactManifolds(struct R3ColliderHandle collider1,
                             struct R3ColliderHandle collider2,
                             struct R3ContactManifold *buffer,
                             size_t capacity);

RAPIER_API
size_t RAPIER_CALL r3SolverContacts(struct R3ColliderHandle collider1,
                           struct R3ColliderHandle collider2,
                           size_t manifold_index,
                           struct R3SolverContact *buffer,
                           size_t capacity);

RAPIER_API
R3Bool RAPIER_CALL r3ContactModificationContext_IsSoft(const struct R3ContactModificationContext *context);

RAPIER_API
size_t RAPIER_CALL r3ContactModificationContext_SolverContactCount(const struct R3ContactModificationContext *context);

RAPIER_API
struct R3SolverContact RAPIER_CALL r3ContactModificationContext_SolverContact(const struct R3ContactModificationContext *context,
                                                                        size_t index);

RAPIER_API
R3Status RAPIER_CALL r3ContactModificationContext_SetSolverContact(struct R3ContactModificationContext *context,
                                                              size_t index,
                                                              const struct R3SolverContact *contact);

RAPIER_API
R3Status RAPIER_CALL r3ContactModificationContext_RemoveSolverContact(struct R3ContactModificationContext *context,
                                                                 size_t index);

RAPIER_API
R3Status RAPIER_CALL r3EventCollector_SetCallbacks(struct R3EventCollector *events,
                                            const struct R3EventCallbacks *callbacks);

RAPIER_API struct R3DebugRenderStyle RAPIER_CALL r3DefaultDebugRenderStyle(void);

RAPIER_API
size_t RAPIER_CALL r3DebugRenderWithStyle(const struct R3World *world,
                                   uint32_t mode,
                                   const struct R3DebugRenderStyle *style,
                                   struct R3DebugLine *buffer,
                                   size_t capacity);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif
 
#endif  /* RAPIER_H */