ammo.idl

interface TopLevelFunctions {
  [Value] static btVector3 quatRotate_([Const, Ref] btQuaternion rotation, [Const, Ref] btVector3 v);
  static void set_gContactAddedCallback(VoidPtr cb);
};

interface AdapterFunctions {
  static void setInternalTickCallback(btDynamicsWorld world, VoidPtr cb, optional VoidPtr worldUserInfo, optional boolean isPreTick);
};

interface Clone {
  static btVector3 Vector3([Const, Ref] btVector3 v);
  static btQuaternion Quaternion([Const, Ref] btQuaternion q);
};

// Linear Math

interface btIDebugDraw {
  void drawLine([Const, Ref] btVector3 from, [Const, Ref] btVector3 to, [Const, Ref] btVector3 color);
  void drawContactPoint([Const, Ref] btVector3 pointOnB, [Const, Ref] btVector3 normalOnB, float distance, long lifeTime, [Const, Ref] btVector3 color);
  void reportErrorWarning([Const] DOMString warningString);
  void draw3dText([Const, Ref] btVector3 location, [Const] DOMString textString);
  void setDebugMode(long debugMode);
  long getDebugMode();
};

[JSImplementation="btIDebugDraw"]
interface DebugDrawer {
  void DebugDrawer();
  void drawLine([Const, Ref] btVector3 from, [Const, Ref] btVector3 to, [Const, Ref] btVector3 color);
  void drawContactPoint([Const, Ref] btVector3 pointOnB, [Const, Ref] btVector3 normalOnB, float distance, long lifeTime, [Const, Ref] btVector3 color);
  void reportErrorWarning([Const] DOMString warningString);
  void draw3dText([Const, Ref] btVector3 location, [Const] DOMString textString);
  void setDebugMode(long debugMode);
  [Const] long getDebugMode();
};

interface btVector3 {
  void btVector3();
  // void btVector3([Const, Ref] btVector3 v);
  void btVector3(float x, float y, float z);
  float length();
  float x();
  float y();
  float z();
  void setX(float x);
  void setY(float y);
  void setZ(float z);
  void setValue(float x, float y, float z);
  void normalize();
  [Value] btVector3 normalized();
  [Value] btVector3 rotate([Const, Ref] btVector3 wAxis, [Const] float angle);
  float dot([Ref] btVector3 v);
  float angle([Const, Ref] btVector3 v);
  [Value] btVector3 absolute();
  [Value] btVector3 cross([Const, Ref] btVector3 v);
  float triple([Const, Ref] btVector3 v1, [Const, Ref] btVector3 v2);
  long minAxis();
  long maxAxis();
  long furthestAxis();
  long closestAxis();
  void setInterpolate3([Const, Ref] btVector3 v0, [Const, Ref] btVector3 v1, float rt);
  // [Value] btVector3 lerp([Const, Ref] btVector3 v, [Const, Ref] float t);
  [Operator="*=", Ref] btVector3 op_mul(float x);
  [Operator="+=", Ref] btVector3 op_add([Ref] btVector3 v);
  [Operator="-=", Ref] btVector3 op_sub([Ref] btVector3 v);
};

interface btVector4 {
  void btVector4();
  void btVector4(float x, float y, float z, float w);
  float w();
  [Value] btVector4 absolute4();
  long maxAxis4();
  long minAxis4();
  long closestAxis4();
  [Operator="="] void op_set([Const, Ref] btVector4 v);
  
  // cannot be included because btVector4 doesn't implement btVector3::setValue(x, y, z)
  // void setValue(float x, float y, float z, float w);

  float length();
  float x();
  float y();
  float z();
  void setX(float x);
  void setY(float y);
  void setZ(float z);
  void normalize();
  [Value] btVector3 normalized();
  [Value] btVector3 rotate([Const, Ref] btVector3 wAxis, [Const] float angle);
  float dot([Ref] btVector3 v);
  float angle([Const, Ref] btVector3 v);
  [Value] btVector3 absolute();
  [Value] btVector3 cross([Const, Ref] btVector3 v);
  float triple([Const, Ref] btVector3 v1, [Const, Ref] btVector3 v2);
  long minAxis();
  long maxAxis();
  long furthestAxis();
  long closestAxis();
  void setInterpolate3([Const, Ref] btVector3 v0, [Const, Ref] btVector3 v1, float rt);
  // [Value] btVector3 lerp([Const, Ref] btVector3 v, [Const, Ref] float t);
  [Operator="*=", Ref] btVector3 op_mul(float x);
  [Operator="+=", Ref] btVector3 op_add([Ref] btVector3 v);
  [Operator="-=", Ref] btVector3 op_sub([Ref] btVector3 v);
};
// //btVector4 implements btVector3;

interface btQuadWord {
  float x();
  float y();
  float z();
  float w();
  void setX(float x);
  void setY(float y);
  void setZ(float z);
  void setW(float w);
};

interface btQuaternion {
  void btQuaternion();
  // void btQuaternion([Const, Ref] btQuaternion q);
  void btQuaternion(float x, float y, float z, float w);
  void setValue(float x, float y, float z, float w);
  void setEulerZYX(float z, float y, float x);
  void setRotation([Ref] btVector3 axis, float angle);
  void normalize();
  float length2();
  float length();
  float dot([Ref] btQuaternion q);
  [Value] btQuaternion normalized();
  [Value] btVector3 getAxis();
  [Value] btQuaternion inverse();
  float getAngle();
  float getAngleShortestPath();
  float angle([Ref] btQuaternion q);
  float angleShortestPath([Ref] btQuaternion q);
  [Operator="+=", Ref] btQuaternion op_add([Ref] btQuaternion q);
  [Operator="-=", Ref] btQuaternion op_sub([Ref] btQuaternion q);
  [Operator="*=", Ref] btQuaternion op_mul(float s);
  [Operator="*=", Ref] btQuaternion op_mulq([Ref] btQuaternion q);
  [Operator="/=", Ref] btQuaternion op_div(float s);
};
btQuaternion implements btQuadWord;

interface btMatrix3x3 {
  void setEulerZYX(float ex, float ey, float ez);
  void getRotation([Ref] btQuaternion q);
  [Value] btVector3 getRow(long y);
};

interface btTransform {
  void btTransform();
  void btTransform([Ref] btQuaternion q, [Ref] btVector3 v);

  void setIdentity();
  void setOrigin([Ref] btVector3 origin);
  void setRotation([Ref] btQuaternion rotation);
  [Ref] btVector3 getOrigin();
  [Value] btQuaternion getRotation();
  [Ref] btMatrix3x3 getBasis();
  void setFromOpenGLMatrix(float[] m);
  [Value] btTransform inverse();
  [Operator="*=", Ref] btTransform op_mul([Ref] btTransform t);
};

interface btMotionState {
  void getWorldTransform([Ref] btTransform worldTrans);
  void setWorldTransform([Ref] btTransform worldTrans);
};

[JSImplementation="btMotionState"]
interface MotionState {
  void MotionState();
  [Const] void getWorldTransform([Ref] btTransform worldTrans);
  void setWorldTransform([Const, Ref] btTransform worldTrans);
};

interface btDefaultMotionState {
  void btDefaultMotionState([Ref] optional btTransform startTrans, [Ref] optional btTransform centerOfMassOffset);
  [Value] attribute btTransform m_graphicsWorldTrans;
};
btDefaultMotionState implements btMotionState;

interface btSpatialForceVector {
	[Value] attribute btVector3 m_topVec;
  [Value] attribute btVector3 m_bottomVec;
	//
	void btSpatialForceVector();
	void btSpatialForceVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	// void btSpatialForceVector([Const, Ref] float ax, [Const, Ref] float ay, [Const, Ref] float az, [Const, Ref] float lx, [Const, Ref] float ly, [Const, Ref] float lz);
	//
	void setVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	// void setValue([Const, Ref] float ax, [Const, Ref] float ay, [Const, Ref] float az, [Const, Ref] float lx, [Const, Ref] float ly, [Const, Ref] float lz);
	//
	void addVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	// void addValue([Const, Ref] float ax, [Const, Ref] float ay, [Const, Ref] float az, [Const, Ref] float lx, [Const, Ref] float ly, [Const, Ref] float lz);
	//
	[Const, Ref] btVector3 getLinear();
	[Const, Ref] btVector3 getAngular();
	//
	void setLinear([Const, Ref] btVector3 linear);
	void setAngular([Const, Ref] btVector3 angular);
	//
	void addAngular([Const, Ref] btVector3 angular);
	void addLinear([Const, Ref] btVector3 linear);
	//
	void setZero();
	//
	[Operator="+=", Ref] btSpatialForceVector op_add([Const, Ref] btSpatialForceVector vec);
	[Operator="-=", Ref] btSpatialForceVector op_sub([Const, Ref] btSpatialForceVector vec);
};

interface btSpatialMotionVector
{
	[Value] attribute btVector3 m_topVec;
  [Value] attribute btVector3 m_bottomVec;
	
	void btSpatialMotionVector();
	void btSpatialMotionVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	
	void setVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	// void setValue([Const, Ref] float ax, [Const, Ref] float ay, [Const, Ref] float az, [Const, Ref] float lx, [Const, Ref] float ly, [Const, Ref] float lz);
	void addVector([Const, Ref] btVector3 angular, [Const, Ref] btVector3 linear);
	// void addValue([Const, Ref] float ax, [Const, Ref] float ay, [Const, Ref] float az, [Const, Ref] float lx, [Const, Ref] float ly, [Const, Ref] float lz);
	
	[Const, Ref] btVector3 getAngular();
	[Const, Ref] btVector3 getLinear();
	
	void setAngular([Const, Ref] btVector3 angular);
	void setLinear([Const, Ref] btVector3 linear);
	
	void addAngular([Const, Ref] btVector3 angular);
	void addLinear([Const, Ref] btVector3 linear);
	
	void setZero();
	float dot([Const, Ref] btSpatialForceVector b);
	
	[Operator="+=", Ref] btSpatialMotionVector op_add([Const, Ref] btSpatialMotionVector vec);
  [Operator="-=", Ref] btSpatialMotionVector op_sub([Const, Ref] btSpatialMotionVector vec);
	// [Operator="*=", Ref] btSpatialMotionVector op_mul([Const, Ref] float s);
};

interface btSymmetricSpatialDyad {
	[Value] attribute btMatrix3x3 m_topLeftMat;
  [Value] attribute btMatrix3x3 m_topRightMat;
  [Value] attribute btMatrix3x3 m_bottomLeftMat;
	void btSymmetricSpatialDyad();
	void btSymmetricSpatialDyad([Const, Ref] btMatrix3x3 topLeftMat, [Const, Ref] btMatrix3x3 topRightMat, [Const, Ref] btMatrix3x3 bottomLeftMat);
	void setMatrix([Const, Ref] btMatrix3x3 topLeftMat, [Const, Ref] btMatrix3x3 topRightMat, [Const, Ref] btMatrix3x3 bottomLeftMat);
	void addMatrix([Const, Ref] btMatrix3x3 topLeftMat, [Const, Ref] btMatrix3x3 topRightMat, [Const, Ref] btMatrix3x3 bottomLeftMat);
	void setIdentity();
	[Operator="-=", Ref] btSymmetricSpatialDyad op_sub([Const, Ref] btSymmetricSpatialDyad mat);
};

// Collision

enum btCollisionObject_CollisionFlags {
  "btCollisionObject::CF_DYNAMIC_OBJECT",
  "btCollisionObject::CF_STATIC_OBJECT",
  "btCollisionObject::CF_KINEMATIC_OBJECT",
  "btCollisionObject::CF_NO_CONTACT_RESPONSE",
  "btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK",  //this allows per-triangle material (friction/restitution)
  "btCollisionObject::CF_CHARACTER_OBJECT",
  "btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT",          //disable debug drawing
  "btCollisionObject::CF_DISABLE_SPU_COLLISION_PROCESSING",  //disable parallel/SPU processing
  "btCollisionObject::CF_HAS_CONTACT_STIFFNESS_DAMPING",
  "btCollisionObject::CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR",
  "btCollisionObject::CF_HAS_FRICTION_ANCHOR",
  "btCollisionObject::CF_HAS_COLLISION_SOUND_TRIGGER"
};

enum btCollisionObject_CollisionObjectTypes {
  "btCollisionObject::CO_COLLISION_OBJECT",
  "btCollisionObject::CO_RIGID_BODY",
  "btCollisionObject::CO_GHOST_OBJECT",
  "btCollisionObject::CO_SOFT_BODY",
  "btCollisionObject::CO_HF_FLUID",
  "btCollisionObject::CO_USER_TYPE",
  "btCollisionObject::CO_FEATHERSTONE_LINK"
};

enum btCollisionObject_AnisotropicFrictionFlags {
  "btCollisionObject::CF_ANISOTROPIC_FRICTION_DISABLED",
  "btCollisionObject::CF_ANISOTROPIC_FRICTION",
  "btCollisionObject::CF_ANISOTROPIC_ROLLING_FRICTION"
};

interface btCollisionObject {
  [Const, Ref] btVector3 getAnisotropicFriction();
  void setAnisotropicFriction([Const, Ref] btVector3 anisotropicFriction, long frictionMode);
  boolean hasAnisotropicFriction(optional long frictionMode);
  btCollisionShape getCollisionShape();
  float getContactProcessingThreshold();
  void setContactProcessingThreshold(float contactProcessingThreshold);
  long getActivationState();
  void setActivationState(long newState);
  void forceActivationState(long newState);
  void activate(optional boolean forceActivation);
  void setDeactivationTime(float time);
  float getDeactivationTime();
  boolean isActive();
  boolean isKinematicObject();
  boolean isStaticObject();
  boolean isStaticOrKinematicObject();
  [Const] float getRestitution();
  [Const] float getFriction();
  [Const] float getRollingFriction();
  float getSpinningFriction();
  float getContactStiffness();
  float getContactDamping();
  void setRestitution(float rest);
  void setFriction(float frict);
  void setRollingFriction(float frict);
  void setSpinningFriction(float frict);
  void setContactStiffnessAndDamping(float stiffness, float damping);
  [Ref] btTransform getWorldTransform();
  long getCollisionFlags();
  void setCollisionFlags(long flags);
  void setWorldTransform([Const, Ref] btTransform worldTrans);
  void setCollisionShape(btCollisionShape collisionShape);
  void setCcdMotionThreshold (float ccdMotionThreshold);
  void setCcdSweptSphereRadius (float radius);
  long getUserIndex();
  long getUserIndex2();
  long getUserIndex3();
  void setUserIndex(long index);
  void setUserIndex2(long index);
  void setUserIndex3(long index);
  VoidPtr getUserPointer();
  void setUserPointer(VoidPtr userPointer);
  [Const] btBroadphaseProxy getBroadphaseHandle();
};

[NoDelete]
interface btCollisionObjectWrapper {
  [Const, Ref] btTransform getWorldTransform();
  [Const] btCollisionObject getCollisionObject();
  [Const] btCollisionShape getCollisionShape();
};

[Prefix="btCollisionWorld::"]
interface RayResultCallback {
  // abstract base class, no constructor
  boolean hasHit();
  attribute long m_collisionFilterGroup;
  attribute long m_collisionFilterMask;
  attribute float m_closestHitFraction;
  [Const] attribute btCollisionObject m_collisionObject;
  attribute unsigned long m_flags;
};

[Prefix="btCollisionWorld::"]
interface ClosestRayResultCallback {
  void ClosestRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);

  [Value] attribute btVector3 m_rayFromWorld;
  [Value] attribute btVector3 m_rayToWorld;
  [Value] attribute btVector3 m_hitNormalWorld;
  [Value] attribute btVector3 m_hitPointWorld;
};
ClosestRayResultCallback implements RayResultCallback;

interface btConstCollisionObjectArray {
  long size();
  [Const] btCollisionObject at(long n);
};

interface btScalarArray {
  long size();
  float at(long n);
};

[Prefix="btCollisionWorld::"]
interface AllHitsRayResultCallback {
  void AllHitsRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);

  [Value] attribute btConstCollisionObjectArray m_collisionObjects;
  [Value] attribute btVector3 m_rayFromWorld;
  [Value] attribute btVector3 m_rayToWorld;
  [Value] attribute btVector3Array m_hitNormalWorld;
  [Value] attribute btVector3Array m_hitPointWorld;
  [Value] attribute btScalarArray m_hitFractions;
};
AllHitsRayResultCallback implements RayResultCallback;

interface btManifoldPoint {
  [Const, Ref] btVector3 getPositionWorldOnA();
  [Const, Ref] btVector3 getPositionWorldOnB();
  [Const] double getAppliedImpulse();
  [Const] double getDistance();
  [Value] attribute btVector3 m_localPointA;
  [Value] attribute btVector3 m_localPointB;
  [Value] attribute btVector3 m_positionWorldOnB;
  [Value] attribute btVector3 m_positionWorldOnA;
  [Value] attribute btVector3 m_normalWorldOnB;

  // Contact callback support
  attribute any m_userPersistentData;
};

[Prefix="btCollisionWorld::"]
interface ContactResultCallback {
  float addSingleResult([Ref] btManifoldPoint cp, [Const] btCollisionObjectWrapper colObj0Wrap, long partId0, long index0, [Const] btCollisionObjectWrapper colObj1Wrap, long partId1, long index1);
};

[JSImplementation="ContactResultCallback"]
interface ConcreteContactResultCallback {
  void ConcreteContactResultCallback();
  float addSingleResult([Ref] btManifoldPoint cp, [Const] btCollisionObjectWrapper colObj0Wrap, long partId0, long index0, [Const] btCollisionObjectWrapper colObj1Wrap, long partId1, long index1);
};

[Prefix="btCollisionWorld::"]
interface LocalShapeInfo {
    attribute long m_shapePart;
    attribute long m_triangleIndex;
 };

[Prefix="btCollisionWorld::"]
interface LocalConvexResult  {
  void LocalConvexResult([Const] btCollisionObject hitCollisionObject, LocalShapeInfo localShapeInfo, [Const, Ref] btVector3 hitNormalLocal, [Const, Ref] btVector3 hitPointLocal, float hitFraction);
  [Const] attribute btCollisionObject m_hitCollisionObject;
  attribute LocalShapeInfo m_localShapeInfo;
  [Value] attribute btVector3 m_hitNormalLocal;
  [Value] attribute btVector3 m_hitPointLocal;
  attribute float m_hitFraction;
};

[Prefix="btCollisionWorld::"]
interface ConvexResultCallback {
  // abstract base class, no constructor
  boolean hasHit();
  attribute short m_collisionFilterGroup;
  attribute short m_collisionFilterMask;
  attribute float m_closestHitFraction;
};

[Prefix="btCollisionWorld::"]
interface ClosestConvexResultCallback {
  void ClosestConvexResultCallback([Const, Ref] btVector3 convexFromWorld, [Const, Ref] btVector3 convexToWorld);
  [Const] attribute btCollisionObject m_hitCollisionObject;
  [Value] attribute btVector3 m_convexFromWorld;
  [Value] attribute btVector3 m_convexToWorld;
  [Value] attribute btVector3 m_hitNormalWorld;
  [Value] attribute btVector3 m_hitPointWorld;
};
ClosestConvexResultCallback implements ConvexResultCallback;

interface btCollisionShape {
  void setLocalScaling([Const, Ref] btVector3 scaling);
  [Const, Ref] btVector3 getLocalScaling();
  void calculateLocalInertia(float mass, [Ref] btVector3 inertia);
  void setMargin(float margin);
  float getMargin();
};

interface btConvexShape {
};
btConvexShape implements btCollisionShape;

interface btConvexTriangleMeshShape {
  void btConvexTriangleMeshShape(btStridingMeshInterface meshInterface, optional boolean calcAabb);
};
btConvexTriangleMeshShape implements btConvexShape;

interface btBoxShape {
  void btBoxShape([Ref] btVector3 boxHalfExtents);
  void setMargin(float margin);
  float getMargin();
};
btBoxShape implements btCollisionShape;

interface btCapsuleShape {
  void btCapsuleShape(float radius, float height);
  void setMargin(float margin);
  float getMargin();
  long getUpAxis();
  float getRadius();
  float getHalfHeight();
};
btCapsuleShape implements btCollisionShape;

interface btCapsuleShapeX {
  void btCapsuleShapeX(float radius, float height);
  void setMargin(float margin);
  float getMargin();
};
btCapsuleShapeX implements btCapsuleShape;

interface btCapsuleShapeZ {
  void btCapsuleShapeZ(float radius, float height);
  void setMargin(float margin);
  float getMargin();
};
btCapsuleShapeZ implements btCapsuleShape;

interface btCylinderShape {
  void btCylinderShape([Ref] btVector3 halfExtents);
  void setMargin(float margin);
  float getMargin();
};
btCylinderShape implements btCollisionShape;

interface btCylinderShapeX {
  void btCylinderShapeX([Ref] btVector3 halfExtents);
  void setMargin(float margin);
  float getMargin();
};
btCylinderShapeX implements btCylinderShape;

interface btCylinderShapeZ {
  void btCylinderShapeZ([Ref] btVector3 halfExtents);
  void setMargin(float margin);
  float getMargin();
};
btCylinderShapeZ implements btCylinderShape;

interface btSphereShape {
  void btSphereShape(float radius);
  void setMargin(float margin);
  float getMargin();
};
btSphereShape implements btCollisionShape;

interface btMultiSphereShape {
  void btMultiSphereShape([Const] btVector3 positions, [Const] float[] radii, long numPoints);
};
btMultiSphereShape implements btCollisionShape;

interface btConeShape {
  void btConeShape(float radius, float height);
};
btConeShape implements btCollisionShape;

interface btConeShapeX {
  void btConeShapeX(float radius, float height);
};
btConeShapeX implements btConeShape;

interface btConeShapeZ {
  void btConeShapeZ(float radius, float height);
};
btConeShapeZ implements btConeShape;

interface btIntArray {
  long size();
  long at(long n);
};

interface btFace {
  [Value] attribute btIntArray m_indices;
  attribute float[] m_plane;
};

interface btVector3Array {
  void btVector3Array();
  long size();
  [Const, Ref] btVector3 at(long n);
  void clear();
  void pop_back();
  void resize(long newsize, [Const, Ref] btVector3? fillData);
  [Ref] btVector3 expandNonInitializing();
  [Ref] btVector3 expand([Const, Ref] btVector3? fillValue);
  void push_back([Const, Ref] btVector3 _Val);
  long capacity();
  void reserve(long _Count);
};

interface btQuaternionArray {
  void btQuaternionArray();
  long size();
  [Const, Ref] btQuaternion at(long n);
  void clear();
  void pop_back();
  void resize(long newsize, [Const, Ref] btQuaternion? fillData);
  [Ref] btQuaternion expandNonInitializing();
  [Ref] btQuaternion expand([Const, Ref] btQuaternion? fillValue);
  void push_back([Const, Ref] btQuaternion _Val);
  long capacity();
  void reserve(long _Count);
};

interface btMatrix3x3Array {
  void btMatrix3x3Array();
  long size();
  [Const, Ref] btMatrix3x3 at(long n);
  void clear();
  void pop_back();
  void resize(long newsize, [Const, Ref] btMatrix3x3? fillData);
  [Ref] btMatrix3x3 expandNonInitializing();
  [Ref] btMatrix3x3 expand([Const, Ref] btMatrix3x3? fillValue);
  void push_back([Const, Ref] btMatrix3x3 _Val);
  long capacity();
  void reserve(long _Count);
};

interface btFaceArray {
  void btFaceArray();
  long size();
  [Const, Ref] btFace at(long n);
  void clear();
  void pop_back();
  void resize(long newsize, [Const, Ref] btFace? fillData);
  [Ref] btFace expandNonInitializing();
  [Ref] btFace expand([Const, Ref] btFace? fillValue);
  void push_back([Const, Ref] btFace _Val);
  long capacity();
  void reserve(long _Count);
};

interface btConvexPolyhedron {
  [Value] attribute btVector3Array m_vertices;
  [Value] attribute btFaceArray m_faces;
};

interface btConvexHullShape {
  void btConvexHullShape([Const] optional float[] points, optional long numPoints);
  void addPoint([Const, Ref] btVector3 point, optional boolean recalculateLocalAABB);
  void setMargin(float margin);
  float getMargin();
  long getNumVertices();
  boolean initializePolyhedralFeatures(long shiftVerticesByMargin);
  void recalcLocalAabb();
  [Const] btConvexPolyhedron getConvexPolyhedron();
};
btConvexHullShape implements btCollisionShape;

interface btShapeHull {
  void btShapeHull(btConvexShape shape);
  boolean buildHull(float margin);
  long numVertices();
  [Const] btVector3 getVertexPointer();
};

interface btCompoundShape {
  void btCompoundShape(optional boolean enableDynamicAabbTree);
  void addChildShape([Const, Ref] btTransform localTransform, btCollisionShape shape);
  void removeChildShape(btCollisionShape shape);
  void removeChildShapeByIndex(long childShapeindex);
  [Const] long getNumChildShapes();
  btCollisionShape getChildShape(long index);
  void updateChildTransform(long childIndex, [Const, Ref] btTransform newChildTransform, optional boolean shouldRecalculateLocalAabb);
  void setMargin(float margin);
  float getMargin();
};
btCompoundShape implements btCollisionShape;

interface btStridingMeshInterface {
  void setScaling([Const, Ref] btVector3 scaling);
};

interface btIndexedMesh {
  attribute long m_numTriangles;
};

interface btIndexedMeshArray {
  long size();
  [Const, Ref] btIndexedMesh at(long n);
};

interface btTriangleMesh {
  void btTriangleMesh(optional boolean use32bitIndices, optional boolean use4componentVertices);
  void addTriangle([Const, Ref] btVector3 vertex0, [Const, Ref] btVector3 vertex1, [Const, Ref] btVector3 vertex2, optional boolean removeDuplicateVertices);
  void addTriangleIndices(long index1, long index2, long index3);
  long findOrAddVertex([Const, Ref] btVector3 vertex, boolean removeDuplicateVertices);
  void addIndex(long index);
 [Ref] btIndexedMeshArray getIndexedMeshArray();
};
btTriangleMesh implements btStridingMeshInterface;

enum PHY_ScalarType {
    "PHY_FLOAT",
    "PHY_DOUBLE",
    "PHY_INTEGER",
    "PHY_SHORT",
    "PHY_FIXEDPOINT88",
    "PHY_UCHAR"
};

interface btTriangleCallback {
	void processTriangle(btVector3 triangle, long partId, long triangleIndex);
};

[JSImplementation="btTriangleCallback"]
interface btTriangleCallback_implJS {
	void processTriangle(btVector3 triangle, long partId, long triangleIndex);
};

interface btConcaveShape {
};
btConcaveShape implements btCollisionShape;

interface btEmptyShape {
  void btEmptyShape();
};
btEmptyShape implements btConcaveShape;

interface btStaticPlaneShape {
  void btStaticPlaneShape([Const, Ref] btVector3 planeNormal, float planeConstant);
};
btStaticPlaneShape implements btConcaveShape;

interface btTriangleMeshShape {
};
btTriangleMeshShape implements btConcaveShape;

interface btBvhTriangleMeshShape {
  void btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, boolean useQuantizedAabbCompression, optional boolean buildBvh);
  
  void performRaycast(btTriangleCallback callback, [Const, Ref] btVector3 raySource, [Const, Ref] btVector3 rayTarget);
};
btBvhTriangleMeshShape implements btTriangleMeshShape;

interface btHeightfieldTerrainShape {
    void btHeightfieldTerrainShape(long heightStickWidth, long heightStickLength, VoidPtr heightfieldData, float heightScale, float minHeight, float maxHeight, long upAxis, PHY_ScalarType hdt, boolean flipQuadEdges);
    void setMargin(float margin);
    float getMargin();
};
btHeightfieldTerrainShape implements btConcaveShape;

// GImpact

interface btAABB {
  void btAABB([ Const, Ref ] btVector3 V1, [ Const, Ref ] btVector3 V2, [ Const, Ref ] btVector3 V3, float margin);
  void invalidate();
  void increment_margin(float margin);
  void copy_with_margin([ Const, Ref ] btAABB other, float margin);
};

interface btPrimitiveTriangle {
  void btPrimitiveTriangle();
};

interface btTriangleShapeEx {
  void btTriangleShapeEx([ Const, Ref ] btVector3 p1, [ Const, Ref ] btVector3 p2, [ Const, Ref ] btVector3 p3);
  void getAabb([ Const, Ref ] btTransform t, [ Ref ] btVector3 aabbMin, [ Ref ] btVector3 aabbMax);
  void applyTransform([ Const, Ref ] btTransform t);
  // void buildTriPlane([ Ref ] btVector4 plane);
};

interface btPrimitiveManagerBase {
  boolean is_trimesh();
  long get_primitive_count();
  void get_primitive_box(long prim_index , [Ref] btAABB primbox);
  void get_primitive_triangle(long prim_index, [Ref] btPrimitiveTriangle triangle);
};

enum eGIMPACT_SHAPE_TYPE {
	"CONST_GIMPACT_COMPOUND_SHAPE",
	"CONST_GIMPACT_TRIMESH_SHAPE_PART",
	"CONST_GIMPACT_TRIMESH_SHAPE"
};

interface btTetrahedronShapeEx {
    void btTetrahedronShapeEx();
    void setVertices([ Const, Ref ] btVector3 v0, [ Const, Ref ] btVector3 v1, [ Const, Ref ] btVector3 v2, [ Const, Ref ] btVector3 v3);
};

interface btGImpactShapeInterface {
  void updateBound();
  void postUpdate();
  long getShapeType();
  [Const] DOMString getName();
  eGIMPACT_SHAPE_TYPE getGImpactShapeType();
  [Const] btPrimitiveManagerBase getPrimitiveManager();
  long getNumChildShapes();
  boolean childrenHasTransform();
  boolean needsRetrieveTriangles();
  boolean needsRetrieveTetrahedrons();
  void getBulletTriangle(long prim_index, [Ref] btTriangleShapeEx triangle);
  void getBulletTetrahedron(long prim_index, [Ref] btTetrahedronShapeEx tetrahedron);
  [Const] btCollisionShape getChildShape(long index);
  [Value] btTransform getChildTransform(long index);
  void setChildTransform(long index, [Const, Ref] btTransform transform);
};
btGImpactShapeInterface implements btConcaveShape;

[Prefix="btGImpactCompoundShape::"]
interface CompoundPrimitiveManager {
  attribute btGImpactCompoundShape m_compoundShape;
  long get_primitive_count();
  void get_primitive_box(long prim_index, [Ref] btAABB primbox);
  void get_primitive_triangle(long prim_index, [Ref] btPrimitiveTriangle triangle);
};
CompoundPrimitiveManager implements btPrimitiveManagerBase;

interface btGImpactCompoundShape {
  void btGImpactCompoundShape(optional boolean children_has_transform = true);
  boolean childrenHasTransform();
  [Const] btPrimitiveManagerBase getPrimitiveManager();
  CompoundPrimitiveManager getCompoundPrimitiveManager();
  long getNumChildShapes();
  void addChildShape([ Const, Ref ] btTransform localTransform, btCollisionShape shape);
  btCollisionShape getChildShape(long index);
  void getChildAabb(long child_index, [ Const, Ref ] btTransform t, [Ref] btVector3 aabbMin, [Ref] btVector3 aabbMax);
  [Value] btTransform	getChildTransform(long index);
  void setChildTransform(long index, [ Const, Ref ] btTransform transform);
  void calculateLocalInertia(float mass, [Ref] btVector3 inertia);
  [Const] DOMString getName();
  eGIMPACT_SHAPE_TYPE getGImpactShapeType();
};
btGImpactCompoundShape implements btGImpactShapeInterface;

[Prefix = "btGImpactMeshShapePart::"]
interface TrimeshPrimitiveManager {
  attribute float m_margin;
  attribute btStridingMeshInterface m_meshInterface;
  attribute long m_part;
  attribute long m_lock_count;
  attribute long numverts;
  attribute PHY_ScalarType type;
  attribute long stride;
  attribute long indexstride;
  attribute long numfaces;
  attribute PHY_ScalarType indicestype;
  void TrimeshPrimitiveManager([Const, Ref] optional TrimeshPrimitiveManager manager);
  void lock();
  void unlock();
  boolean is_trimesh();
  long get_vertex_count();
  void get_indices(long face_index, unsigned long i0, unsigned long i1, unsigned long i2);
  void get_vertex(unsigned long vertex_index, [Ref] btVector3 vertex);
  void get_bullet_triangle(long prim_index, [Ref] btTriangleShapeEx triangle);
};
TrimeshPrimitiveManager implements btPrimitiveManagerBase;

interface btGImpactMeshShapePart {
  void btGImpactMeshShapePart(btStridingMeshInterface meshInterface, long part);
  TrimeshPrimitiveManager getTrimeshPrimitiveManager();
  long getVertexCount();
  void getVertex(long vertex_index, [Ref] btVector3 vertex);
  long getPart();
};
btGImpactMeshShapePart implements btGImpactShapeInterface;

interface btGImpactMeshShape {
  void btGImpactMeshShape(btStridingMeshInterface meshInterface);
  [Const] btStridingMeshInterface getMeshInterface();
  long getMeshPartCount();
  [Const] btGImpactMeshShapePart getMeshPart(long index);
  long calculateSerializeBufferSize();
};
btGImpactMeshShape implements btGImpactShapeInterface;

interface btCollisionAlgorithmConstructionInfo {
	void btCollisionAlgorithmConstructionInfo();
	void btCollisionAlgorithmConstructionInfo(btDispatcher dispatcher, long temp);
	attribute btDispatcher m_dispatcher1;
	attribute btPersistentManifold m_manifold;
};

interface btCollisionAlgorithm {
};

interface btActivatingCollisionAlgorithm {
};
btActivatingCollisionAlgorithm implements btCollisionAlgorithm;

interface btGImpactCollisionAlgorithm {
  void btGImpactCollisionAlgorithm([Const, Ref] btCollisionAlgorithmConstructionInfo ci, [Const] btCollisionObjectWrapper body0Wrap, [Const] btCollisionObjectWrapper body1Wrap);
  static void registerAlgorithm(btCollisionDispatcher dispatcher);
};
btGImpactCollisionAlgorithm implements btActivatingCollisionAlgorithm;

//

interface btDefaultCollisionConstructionInfo {
  void btDefaultCollisionConstructionInfo();
};

interface btDefaultCollisionConfiguration {
  void btDefaultCollisionConfiguration([Ref] optional btDefaultCollisionConstructionInfo info);
};

interface btPersistentManifold {
  void btPersistentManifold();
  [Const] btCollisionObject getBody0();
  [Const] btCollisionObject getBody1();
  long getNumContacts();
  [Ref] btManifoldPoint getContactPoint(long index);
};

interface btDispatcher {
  long getNumManifolds();
  btPersistentManifold getManifoldByIndexInternal(long index);
};

interface btCollisionDispatcher {
  void btCollisionDispatcher(btDefaultCollisionConfiguration conf);
};
btCollisionDispatcher implements btDispatcher;

interface btOverlappingPairCallback {
};

interface btOverlappingPairCache {
  void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback);
  [Const] float getNumOverlappingPairs();
};

interface btAxisSweep3 {
  void btAxisSweep3([Ref] btVector3 worldAabbMin, [Ref] btVector3 worldAabbMax, optional long maxHandles, optional btOverlappingPairCache pairCache, optional boolean disableRaycastAccelerator);
};

interface btBroadphaseInterface {
  btOverlappingPairCache getOverlappingPairCache();
};

interface btCollisionConfiguration {
};

interface btDbvtBroadphase {
  void btDbvtBroadphase();
};
btDbvtBroadphase implements btBroadphaseInterface;

interface btBroadphaseProxy {
  attribute long m_collisionFilterGroup;
  attribute long m_collisionFilterMask;
};


// Dynamics

[Prefix="btRigidBody::"]
interface btRigidBodyConstructionInfo {
  void btRigidBodyConstructionInfo(float mass, btMotionState motionState, btCollisionShape collisionShape, [Ref] optional btVector3 localInertia);
  attribute float m_linearDamping;
  attribute float m_angularDamping;
  attribute float m_friction;
  attribute float m_rollingFriction;
  attribute float m_restitution;
  attribute float m_linearSleepingThreshold;
  attribute float m_angularSleepingThreshold;
  attribute boolean m_additionalDamping;
  attribute float m_additionalDampingFactor;
  attribute float m_additionalLinearDampingThresholdSqr;
  attribute float m_additionalAngularDampingThresholdSqr;
  attribute float m_additionalAngularDampingFactor;
};

interface btRigidBody {
  void btRigidBody([Const, Ref] btRigidBodyConstructionInfo constructionInfo);
  
  [Const, Ref] btTransform getCenterOfMassTransform();
  void setCenterOfMassTransform([Const, Ref] btTransform xform);
  void setSleepingThresholds(float linear, float angular);
	float getLinearSleepingThreshold();
	float getAngularSleepingThreshold();
  [Const] float getLinearDamping();
  [Const] float getAngularDamping();
  void setDamping(float lin_damping, float ang_damping);
  void applyDamping(float timeStep);
  void setMassProps(float mass, [Const, Ref] btVector3 inertia);
	float getInvMass();
	float getMass();
  [Const, Ref] btVector3 getLinearFactor();
  void setLinearFactor([Const, Ref] btVector3 linearFactor);
  void applyTorque([Const, Ref] btVector3 torque);
  // void applyLocalTorque([Const, Ref] btVector3 torque);
  void applyForce([Const, Ref] btVector3 force, [Const, Ref] btVector3 rel_pos);
  // void applyCentralForce([Const, Ref] btVector3 force);
  // void applyCentralLocalForce([Const, Ref] btVector3 force);
  void applyCentralImpulse([Const, Ref] btVector3 impulse);
  void applyTorqueImpulse([Const, Ref] btVector3 torque);
  void applyImpulse([Const, Ref] btVector3 impulse, [Const, Ref] btVector3 rel_pos);
  void applyPushImpulse([Const, Ref] btVector3 impulse, [Const, Ref] btVector3 rel_pos);
  [Value] btVector3 getPushVelocity();
  [Value] btVector3 getTurnVelocity();
  void setPushVelocity([Const, Ref] btVector3 v);
  void setTurnVelocity([Const, Ref] btVector3 v);
  void applyCentralPushImpulse([Const, Ref] btVector3 impulse);
  void applyTorqueTurnImpulse([Const, Ref] btVector3 torque);
  [Const, Ref] btVector3 getCenterOfMassPosition();
  [Value] btQuaternion getOrientation();
	[Const, Ref] btVector3 getTotalForce();
	[Const, Ref] btVector3 getTotalTorque();
	[Const, Ref] btVector3 getInvInertiaDiagLocal();
	void setInvInertiaDiagLocal([Const, Ref] btVector3 diagInvInertia);
  void updateInertiaTensor();
  [Const, Ref] btVector3 getLinearVelocity();
  [Const, Ref] btVector3 getAngularVelocity();
  void setLinearVelocity([Const, Ref] btVector3 lin_vel);
  void setAngularVelocity([Const, Ref] btVector3 ang_vel);
  [Value] btVector3 getVelocityInLocalPoint([Const, Ref] btVector3 rel_pos);
  [Value] btVector3 getPushVelocityInLocalPoint([Const, Ref] btVector3 rel_pos);
  void translate([Const, Ref] btVector3 v);
  btMotionState getMotionState();
  void setMotionState(btMotionState motionState);
  [Const, Ref] btVector3 getAngularFactor();
  void setAngularFactor([Const, Ref] btVector3 angularFactor);
  btRigidBody upcast(btCollisionObject colObj);
  void getAabb([Ref] btVector3 aabbMin, [Ref] btVector3 aabbMax);
  void applyGravity();
  void clearGravity();
  [Const, Ref] btVector3 getGravity();
  void setGravity([Const, Ref] btVector3 acceleration);
  [Const] btBroadphaseProxy getBroadphaseProxy();
  void clearForces();
  void setFlags(long flags);
  [Const] long getFlags();
};
btRigidBody implements btCollisionObject;

interface btSolverBody {
	[Value] attribute btTransform		m_worldTransform;
	[Value] attribute btVector3		m_deltaLinearVelocity;
	[Value] attribute btVector3		m_deltaAngularVelocity;
	[Value] attribute btVector3		m_angularFactor;
	[Value] attribute btVector3		m_linearFactor;
	[Value] attribute btVector3		m_invMass;
	[Value] attribute btVector3		m_pushVelocity;
	[Value] attribute btVector3		m_turnVelocity;
	[Value] attribute btVector3		m_linearVelocity;
	[Value] attribute btVector3		m_angularVelocity;
	[Value] attribute btVector3		m_externalForceImpulse;
	[Value] attribute btVector3		m_externalTorqueImpulse;
	attribute btRigidBody	        m_originalBody;
	void	setWorldTransform([Const, Ref] btTransform worldTransform);
	[Const, Ref] btTransform getWorldTransform();
	void getVelocityInLocalPointNoDelta([Const, Ref] btVector3 rel_pos, [Ref] btVector3 velocity);
	void getVelocityInLocalPointObsolete([Const, Ref] btVector3 rel_pos, [Ref] btVector3 velocity);
	void getAngularVelocity([Ref] btVector3 angVel);
	//Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
	void applyImpulse([Const, Ref] btVector3 linearComponent, [Const, Ref] btVector3 angularComponent, [Const] float impulseMagnitude);
	void internalApplyPushImpulse([Const, Ref] btVector3 linearComponent, [Const, Ref] btVector3 angularComponent, float impulseMagnitude);
	[Const, Ref] btVector3 getDeltaLinearVelocity();
	[Const, Ref] btVector3 getDeltaAngularVelocity();
	[Const, Ref] btVector3 getPushVelocity();
	[Const, Ref] btVector3 getTurnVelocity();
};

interface btSolverBodyArray {
  long size();
  [Const, Ref] btSolverBody at(long n);
};

interface btConstraintSetting {
  void btConstraintSetting();
  attribute float m_tau;
  attribute float m_damping;
  attribute float m_impulseClamp;
};

interface btJointFeedback {
	[Value] attribute btVector3 m_appliedForceBodyA;
	[Value] attribute btVector3 m_appliedTorqueBodyA;
	[Value] attribute btVector3 m_appliedForceBodyB;
	[Value] attribute btVector3 m_appliedTorqueBodyB;
};

interface btTypedConstraint {
	long getOverrideNumSolverIterations();
	///override the number of constraint solver iterations used to solve this constraint
	///-1 will use the default number of iterations, as specified in SolverInfo.m_numIterations
	void setOverrideNumSolverIterations(long overideNumIterations);
  
  void enableFeedback(boolean needsFeedback);
	boolean needsFeedback();

	void setJointFeedback(btJointFeedback jointFeedback);
	[Const] btJointFeedback getJointFeedback();

	///getAppliedImpulse is an estimated total applied impulse. 
	///This feedback could be used to determine breaking constraints or playing sounds.
	float getAppliedImpulse();

	btTypedConstraintType getConstraintType();

  [Const] float getBreakingImpulseThreshold();
  void setBreakingImpulseThreshold([Const] float threshold);
  [Const] float getParam(long num, long axis);
  void setParam(long num, float value, long axis);

	boolean isEnabled();
	void setEnabled(boolean enabled);


	[Const, Ref] btRigidBody getRigidBodyA();
	[Const, Ref] btRigidBody getRigidBodyB();

	long getUserConstraintType();
	void setUserConstraintType(long userConstraintType);

	[Ref] static btRigidBody getFixedBody();
};

enum btTypedConstraintType {
	"POINT2POINT_CONSTRAINT_TYPE",
	"HINGE_CONSTRAINT_TYPE",
	"CONETWIST_CONSTRAINT_TYPE",
	"D6_CONSTRAINT_TYPE",
	"SLIDER_CONSTRAINT_TYPE",
	"CONTACT_CONSTRAINT_TYPE",
	"D6_SPRING_CONSTRAINT_TYPE",
	"GEAR_CONSTRAINT_TYPE",
	"FIXED_CONSTRAINT_TYPE",
	"MAX_CONSTRAINT_TYPE"
};

enum btConstraintParams {
  "BT_CONSTRAINT_ERP",
  "BT_CONSTRAINT_STOP_ERP",
  "BT_CONSTRAINT_CFM",
  "BT_CONSTRAINT_STOP_CFM"
};

interface btPoint2PointConstraint {
  void btPoint2PointConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btVector3 pivotInA, [Ref] btVector3 pivotInB);
  void btPoint2PointConstraint([Ref] btRigidBody rbA, [Ref] btVector3 pivotInA);
  void setPivotA([Const, Ref] btVector3 pivotA);
  void setPivotB([Const, Ref] btVector3 pivotB);
  [Const, Ref] btVector3 getPivotInA();
  [Const, Ref] btVector3 getPivotInB();

  [Value] attribute btConstraintSetting m_setting;
};
btPoint2PointConstraint implements btTypedConstraint;

interface btGeneric6DofConstraint {
  void btGeneric6DofConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btTransform frameInA, [Ref] btTransform frameInB, boolean useLinearFrameReferenceFrameA);
  void btGeneric6DofConstraint([Ref] btRigidBody rbB, [Ref] btTransform frameInB, boolean useLinearFrameReferenceFrameB);
  void setLinearLowerLimit([Const, Ref] btVector3 linearLower);
  void setLinearUpperLimit([Const, Ref] btVector3 linearUpper);
  void setAngularLowerLimit([Const, Ref] btVector3 angularLower);
  void setAngularUpperLimit([Const, Ref] btVector3 angularUpper);
  [Const, Ref] btTransform getFrameOffsetA();
};
btGeneric6DofConstraint implements btTypedConstraint;

interface btGeneric6DofSpringConstraint {
  void btGeneric6DofSpringConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btTransform frameInA, [Ref] btTransform frameInB, boolean useLinearFrameReferenceFrameA);
  void btGeneric6DofSpringConstraint([Ref] btRigidBody rbB, [Ref] btTransform frameInB, boolean useLinearFrameReferenceFrameB);
  void enableSpring(long index, boolean onOff);
  void setStiffness(long index, float stiffness);
  void setDamping(long index, float damping);
  void setEquilibriumPoint(long index, float val);
  void setEquilibriumPoint(long index);
  void setEquilibriumPoint();
};
btGeneric6DofSpringConstraint implements btGeneric6DofConstraint;

interface btSequentialImpulseConstraintSolver {
  void btSequentialImpulseConstraintSolver();
};

interface btConeTwistConstraint {
  void btConeTwistConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btTransform rbAFrame, [Ref] btTransform rbBFrame);
  void btConeTwistConstraint([Ref] btRigidBody rbA, [Ref] btTransform rbAFrame);

  void setLimit(long limitIndex, float limitValue);
  void setAngularOnly(boolean angularOnly);
  void setDamping(float damping);
  void enableMotor(boolean b);
  void setMaxMotorImpulse(float maxMotorImpulse);
  void setMaxMotorImpulseNormalized(float maxMotorImpulse);
  void setMotorTarget([Const,Ref] btQuaternion q);
  void setMotorTargetInConstraintSpace([Const,Ref] btQuaternion q);
};
btConeTwistConstraint implements btTypedConstraint;

interface btHingeConstraint {
  void btHingeConstraint ([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btVector3 pivotInA, [Ref] btVector3 pivotInB, [Ref] btVector3 axisInA, [Ref] btVector3 axisInB, optional boolean useReferenceFrameA);
  //void btHingeConstraint ([Ref] btRigidBody rbA, [Ref] btVector3 pivotInA, [Ref] btVector3 axisInA, optional boolean useReferenceFrameA);
  void btHingeConstraint ([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Ref] btTransform rbAFrame, [Ref] btTransform rbBFrame, optional boolean useReferenceFrameA);
  void btHingeConstraint ([Ref] btRigidBody rbA, [Ref] btTransform rbAFrame, optional boolean useReferenceFrameA);

  float getHingeAngle();

  void setLimit(float low, float high, float softness, float biasFactor, optional float relaxationFactor);
  void enableAngularMotor(boolean enableMotor, float targetVelocity, float maxMotorImpulse);
  void setAngularOnly(boolean angularOnly);

  void enableMotor(boolean enableMotor);
  void setMaxMotorImpulse(float maxMotorImpulse);
  //void setMotorTarget([Const,Ref] btQuaternion qAinB, float dt);
  void setMotorTarget(float targetAngle, float dt);
};
btHingeConstraint implements btTypedConstraint;

interface btSliderConstraint {
  void btSliderConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Const,Ref] btTransform frameInA, [Const,Ref] btTransform frameInB, boolean useLinearReferenceFrameA);
  void btSliderConstraint([Ref] btRigidBody rbB, [Const,Ref] btTransform frameInB, boolean useLinearReferenceFrameA);

  [Const] float getLinearPos();
  [Const] float getAngularPos();

  void setLowerLinLimit(float lowerLimit);
  void setUpperLinLimit(float upperLimit);
  void setLowerAngLimit(float lowerAngLimit);
  void setUpperAngLimit(float upperAngLimit);

  void setPoweredLinMotor(boolean onOff);
  void setMaxLinMotorForce(float maxLinMotorForce);
  void setTargetLinMotorVelocity(float targetLinMotorVelocity);
};
btSliderConstraint implements btTypedConstraint;

interface btFixedConstraint {
  void btFixedConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Const,Ref] btTransform frameInA, [Const,Ref] btTransform frameInB);
};
btFixedConstraint implements btTypedConstraint;

enum btConstraintSolverType {
	"BT_SEQUENTIAL_IMPULSE_SOLVER",
	"BT_MLCP_SOLVER"
};

interface btConstraintSolver {
};

interface btDispatcherInfo {
  attribute float m_timeStep;
  attribute long m_stepCount;
  attribute long m_dispatchFunc;
  attribute float m_timeOfImpact;
  attribute boolean m_useContinuous;
  attribute boolean m_enableSatConvex;
  attribute boolean m_enableSPU;
  attribute boolean m_useEpa;
  attribute float m_allowedCcdPenetration;
  attribute boolean m_useConvexConservativeDistanceUtil;
  attribute float m_convexConservativeDistanceThreshold;
};

interface btCollisionWorld {
  btDispatcher getDispatcher();
  void rayTest([Const, Ref] btVector3 rayFromWorld, [Const, Ref] btVector3 rayToWorld, [Ref] RayResultCallback resultCallback);
  btOverlappingPairCache getPairCache();
  [Ref] btDispatcherInfo getDispatchInfo();
  void addCollisionObject(btCollisionObject collisionObject, optional short collisionFilterGroup, optional short collisionFilterMask);
  void removeCollisionObject(btCollisionObject collisionObject);
  [Const] btBroadphaseInterface getBroadphase ();
  void convexSweepTest([Const] btConvexShape castShape, [Const, Ref] btTransform from, [Const, Ref] btTransform to, [Ref] ConvexResultCallback resultCallback, float allowedCcdPenetration);
  void contactPairTest(btCollisionObject colObjA, btCollisionObject colObjB, [Ref] ContactResultCallback resultCallback);
  void contactTest(btCollisionObject colObj, [Ref] ContactResultCallback resultCallback);
  void updateSingleAabb(btCollisionObject colObj);
  void setDebugDrawer(btIDebugDraw debugDrawer);
  btIDebugDraw getDebugDrawer();
  void debugDrawWorld();
  void debugDrawObject([Const, Ref] btTransform worldTransform, [Const] btCollisionShape shape, [Const, Ref] btVector3 color);
};

interface btContactSolverInfo {
  attribute boolean m_splitImpulse;
  attribute long m_splitImpulsePenetrationThreshold;
  attribute long m_numIterations;
  attribute float m_erp; //error reduction for non-contact constraints
  attribute float m_erp2; //error reduction for contact constraints
};

interface btDynamicsWorld {
  void addAction(btActionInterface action);
  void removeAction(btActionInterface action);
  [Ref] btContactSolverInfo getSolverInfo();
  //https://emscripten.org/docs/porting/guidelines/function_pointer_issues.html
  // void setInternalTickCallback(VoidPtr cb, optional VoidPtr worldUserInfo, optional boolean isPreTick);
};
btDynamicsWorld implements btCollisionWorld;

interface btDiscreteDynamicsWorld {
  void btDiscreteDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration);

  void setGravity([Ref] btVector3 gravity);
  [Value] btVector3 getGravity();

  void addRigidBody(btRigidBody body);
  void addRigidBody(btRigidBody body, short group, short mask);
  void removeRigidBody(btRigidBody body);

  void addConstraint(btTypedConstraint constraint, optional boolean disableCollisionsBetweenLinkedBodies);
  void removeConstraint(btTypedConstraint constraint);

  long stepSimulation(float timeStep, optional long maxSubSteps, optional float fixedTimeStep);
};
btDiscreteDynamicsWorld implements btDynamicsWorld;

[Prefix="btRaycastVehicle::", NoDelete]
interface btVehicleTuning {
  void btVehicleTuning();
  attribute float m_suspensionStiffness;
  attribute float m_suspensionCompression;
  attribute float m_suspensionDamping;
  attribute float m_maxSuspensionTravelCm;
  attribute float m_frictionSlip;
  attribute float m_maxSuspensionForce;
};

[Prefix="btDefaultVehicleRaycaster::"]
interface btVehicleRaycasterResult {
    [Value] attribute btVector3 m_hitPointInWorld;
    [Value] attribute btVector3 m_hitNormalInWorld;
    attribute float m_distFraction;
};

interface btVehicleRaycaster {
    void castRay ([Const, Ref] btVector3 from, [Const, Ref] btVector3 to, [Ref] btVehicleRaycasterResult result);
};

interface btDefaultVehicleRaycaster {
  void btDefaultVehicleRaycaster(btDynamicsWorld world);
};
btDefaultVehicleRaycaster implements btVehicleRaycaster;

[Prefix="btWheelInfo::"]
interface RaycastInfo {
  [Value] attribute btVector3 m_contactNormalWS;
  [Value] attribute btVector3 m_contactPointWS;
  attribute float m_suspensionLength;
  [Value] attribute btVector3 m_hardPointWS;
  [Value] attribute btVector3 m_wheelDirectionWS;
  [Value] attribute btVector3 m_wheelAxleWS;
  attribute boolean m_isInContact;
  attribute any m_groundObject;
};

interface btWheelInfoConstructionInfo {
    [Value] attribute btVector3 m_chassisConnectionCS;
    [Value] attribute btVector3 m_wheelDirectionCS;
    [Value] attribute btVector3 m_wheelAxleCS;
    attribute float m_suspensionRestLength;
    attribute float m_maxSuspensionTravelCm;
    attribute float m_wheelRadius;
    attribute float m_suspensionStiffness;
    attribute float m_wheelsDampingCompression;
    attribute float m_wheelsDampingRelaxation;
    attribute float m_frictionSlip;
    attribute float m_maxSuspensionForce;
    attribute boolean m_bIsFrontWheel;
};

interface btWheelInfo {
  attribute float m_suspensionStiffness;
  attribute float m_frictionSlip;
  attribute float m_engineForce;
  attribute float m_rollInfluence;
  attribute float m_suspensionRestLength1;
  attribute float m_wheelsRadius;
  attribute float m_wheelsDampingCompression;
  attribute float m_wheelsDampingRelaxation;
  attribute float m_steering;
  attribute float m_maxSuspensionForce;
  attribute float m_maxSuspensionTravelCm;
  attribute float m_wheelsSuspensionForce;
  attribute boolean m_bIsFrontWheel;
  [Value] attribute RaycastInfo m_raycastInfo;
  [Value] attribute btVector3 m_chassisConnectionPointCS;
  void btWheelInfo([Ref] btWheelInfoConstructionInfo ci);
  float getSuspensionRestLength ();
  void  updateWheel ([Const, Ref] btRigidBody chassis, [Ref] RaycastInfo raycastInfo);
  [Value] attribute btTransform m_worldTransform;
  [Value] attribute btVector3 m_wheelDirectionCS;
  [Value] attribute btVector3 m_wheelAxleCS;
  attribute float m_rotation;
  attribute float m_deltaRotation;
  attribute float m_brake;
  attribute float  m_clippedInvContactDotSuspension;
  attribute float  m_suspensionRelativeVelocity;
  attribute float  m_skidInfo;
};

interface btActionInterface {
    void updateAction (btCollisionWorld collisionWorld, float deltaTimeStep);
};

interface btKinematicCharacterController {
  void btKinematicCharacterController(btPairCachingGhostObject ghostObject, btConvexShape convexShape, float stepHeight, [Const, Ref] optional btVector3 up);

  [Const, Ref] btVector3 getUp();
  void setUp ([Const, Ref] btVector3 axis);
  
	/// This should probably be called setPositionIncrementPerSimulatorStep.
	/// This is neither a direction nor a velocity, but the amount to
	///	increment the position each simulation iteration, regardless
	///	of dt.
	/// This call will reset any velocity set by setVelocityForTimeInterval().
	void setWalkDirection([Const, Ref] btVector3 walkDirection);

	/// Caller provides a velocity with which the character should move for
	///	the given time period.  After the time period, velocity is reset
	///	to zero.
	/// This call will reset any walk direction set by setWalkDirection().
	/// Negative time intervals will result in no motion.
	void setVelocityForTimeInterval([Const, Ref] btVector3 velocity,
											float timeInterval);

	void setAngularVelocity([Const, Ref] btVector3 velocity);
	[Const, Ref] btVector3 getAngularVelocity();

	void setLinearVelocity([Const, Ref] btVector3 velocity);
	[Value] btVector3 getLinearVelocity();

	void setLinearDamping(float d);
	float getLinearDamping();
	void setAngularDamping(float d);
	float getAngularDamping();

	void reset(btCollisionWorld collisionWorld);
	void warp([Const, Ref] btVector3 origin);

	void preStep(btCollisionWorld collisionWorld);
	void playerStep(btCollisionWorld collisionWorld, float dt);

	void setStepHeight(float h);
	float getStepHeight();
	void setFallSpeed(float fallSpeed);
	float getFallSpeed();
	void setJumpSpeed(float jumpSpeed);
	float getJumpSpeed();
	void setMaxJumpHeight(float maxJumpHeight);
	boolean canJump();

	void jump([Const, Ref] optional btVector3 v);

	void applyImpulse([Const, Ref] btVector3 v);

	void setGravity([Const, Ref] btVector3 gravity);
	[Value] btVector3 getGravity();

	/// The max slope determines the maximum angle that the controller can walk up.
	/// The slope angle is measured in radians.
	void setMaxSlope(float slopeRadians);
	float getMaxSlope();

	void setMaxPenetrationDepth(float d);
	float getMaxPenetrationDepth();

	btPairCachingGhostObject getGhostObject();
	void setUseGhostSweepTest(boolean useGhostObjectSweepTest);
	boolean onGround();
	void setUpInterpolate(boolean value);
};
btKinematicCharacterController implements btActionInterface;

interface btRaycastVehicle {
  void btRaycastVehicle([Const, Ref] btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster);
  void applyEngineForce(float force, long wheel);
  void setSteeringValue(float steering, long wheel);
  [Const, Ref] btTransform getWheelTransformWS(long wheelIndex);
  void updateWheelTransform(long wheelIndex, boolean interpolatedTransform);
  [Ref] btWheelInfo addWheel([Const, Ref] btVector3 connectionPointCS0, [Const, Ref] btVector3 wheelDirectionCS0, [Const, Ref] btVector3 wheelAxleCS, float suspensionRestLength, float wheelRadius, [Const, Ref] btVehicleTuning tuning, boolean isFrontWheel);
  long getNumWheels();
  btRigidBody getRigidBody();
  [Ref] btWheelInfo getWheelInfo(long index);
  void setBrake(float brake, long wheelIndex);
  void setCoordinateSystem(long rightIndex, long upIndex, long forwardIndex);
  float getCurrentSpeedKmHour();
  [Const, Ref] btTransform getChassisWorldTransform();
  float rayCast([Ref] btWheelInfo wheel);
  void updateVehicle(float step);
  void resetSuspension();
  float getSteeringValue(long wheel);
  void updateWheelTransformsWS([Ref] btWheelInfo wheel, optional boolean interpolatedTransform);
  void setPitchControl(float pitch);
  void updateSuspension(float deltaTime);
  void updateFriction(float timeStep);
  long getRightAxis();
  long getUpAxis();
  long getForwardAxis();
  [Value] btVector3 getForwardVector();
  long getUserConstraintType();
  void setUserConstraintType(long userConstraintType);
  void setUserConstraintId(long uid);
  long getUserConstraintId();
};
btRaycastVehicle implements btActionInterface;

interface btGhostObject {
  void btGhostObject();
  long getNumOverlappingObjects();
  btCollisionObject getOverlappingObject(long index);
};
btGhostObject implements btCollisionObject;

interface btPairCachingGhostObject {
  void btPairCachingGhostObject();
};
btPairCachingGhostObject implements btGhostObject;

interface btGhostPairCallback {
  void btGhostPairCallback();
};

// interface btMultiBodyJointFeedback {
// 	[Value] attribute btSpatialForceVector m_reactionForces;
// };

enum btMultibodyLink_eFeatherstoneJointType {
  "btMultibodyLink::eRevolute",
  "btMultibodyLink::ePrismatic",
  "btMultibodyLink::eSpherical",
  "btMultibodyLink::ePlanar",
  "btMultibodyLink::eFixed",
  "btMultibodyLink::eInvalid"
};

interface btMultibodyLink {
	attribute float m_mass;           // mass of link
	[Value] attribute btVector3  m_inertiaLocal;  // inertia of link (local frame; diagonal)

	attribute long m_parent;  // index of the parent link (assumed to be < index of this link), or -1 if parent is the base link.

	[Value] attribute btQuaternion m_zeroRotParentToThis;  // rotates vectors in parent-frame to vectors in local-frame (when q=0). constant.

	[Value] attribute btVector3 m_dVector;  // vector from the inboard joint pos to this link's COM. (local frame.) constant.
						  //this is set to zero for planar joint (see also m_eVector comment)

	// m_eVector is constant, but depends on the joint type:
	// revolute, fixed, prismatic, spherical: vector from parent's COM to the pivot point, in PARENT's frame.
	// planar: vector from COM of parent to COM of this link, WHEN Q = 0. (local frame.)
	// todo: fix the planar so it is consistent with the other joints

	[Value] attribute btVector3 m_eVector;

  [Value] attribute btSpatialMotionVector m_absFrameTotVelocity;
  [Value] attribute btSpatialMotionVector m_absFrameLocVelocity;

	// "axis" = spatial joint axis (Mirtich Defn 9 p104). (expressed in local frame.) constant.
	// for prismatic: m_axesTop[0] = zero;
	//                m_axesBottom[0] = unit vector along the joint axis.
	// for revolute: m_axesTop[0] = unit vector along the rotation axis (u);
	//               m_axesBottom[0] = u cross m_dVector (i.e. COM linear motion due to the rotation at the joint)
	//
	// for spherical: m_axesTop[0][1][2] (u1,u2,u3) form a 3x3 identity matrix (3 rotation axes)
	//				  m_axesBottom[0][1][2] cross u1,u2,u3 (i.e. COM linear motion due to the rotation at the joint)
	//
	// for planar: m_axesTop[0] = unit vector along the rotation axis (u); defines the plane of motion
	//			   m_axesTop[1][2] = zero
	//			   m_axesBottom[0] = zero
	//			   m_axesBottom[1][2] = unit vectors along the translational axes on that plane
	// btSpatialMotionVector m_axes[6];
	void setAxisTop(long dof, [Const, Ref] btVector3 axis);
	void setAxisBottom(long dof, [Const, Ref] btVector3 axis);
	// void setAxisTop(long dof, [Const, Ref] float x, [Const, Ref] float y, [Const, Ref] float z);
	// void setAxisBottom(long dof, [Const, Ref] float x, [Const, Ref] float y, [Const, Ref] float z);
	[Const, Ref] btVector3 getAxisTop(long dof);
	[Const, Ref] btVector3 getAxisBottom(long dof);

	attribute long m_dofOffset;
  attribute long m_cfgOffset;

	[Value] attribute btQuaternion m_cachedRotParentToThis;  // rotates vectors in parent frame to vectors in local frame
	[Value] attribute btVector3 m_cachedRVector;             // vector from COM of parent to COM of this link, in local frame.
    
  // predicted verstion
  [Value] attribute btQuaternion m_cachedRotParentToThis_interpolate;  // rotates vectors in parent frame to vectors in local frame
  [Value] attribute btVector3 m_cachedRVector_interpolate;             // vector from COM of parent to COM of this link, in local frame.

	[Value] attribute btVector3 m_appliedForce;   // In WORLD frame
	[Value] attribute btVector3 m_appliedTorque;  // In WORLD frame

	[Value] attribute btVector3 m_appliedConstraintForce;   // In WORLD frame
	[Value] attribute btVector3 m_appliedConstraintTorque;  // In WORLD frame

	// attribute float[7] m_jointPos;
  // attribute float[7] m_jointPos_interpolate;

	//m_jointTorque is the joint torque applied by the user using 'addJointTorque'.
	//It gets set to zero after each internal stepSimulation call
	// attribute float[6] m_jointTorque;

	attribute btMultiBodyLinkCollider m_collider;
	attribute long m_flags;

	attribute long m_dofCount;
  attribute long m_posVarCount;  //redundant but handy

	attribute btMultibodyLink_eFeatherstoneJointType m_jointType;

	// attribute btMultiBodyJointFeedback m_jointFeedback;

	[Value] attribute btTransform m_cachedWorldTransform;  //this cache is updated when calling btMultiBody::forwardKinematics

	[Const] attribute DOMString m_linkName;   //m_linkName memory needs to be managed by the developer/user!
	[Const] attribute DOMString m_jointName;  //m_jointName memory needs to be managed by the developer/user!
	[Const] attribute VoidPtr m_userPtr;    //m_userPtr ptr needs to be managed by the developer/user!

	attribute float m_jointDamping;      //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual damping.
	attribute float m_jointFriction;     //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual friction using a velocity motor.
	attribute float m_jointLowerLimit;   //todo: implement this internally. It is unused for now, it is set by a URDF loader.
	attribute float m_jointUpperLimit;   //todo: implement this internally. It is unused for now, it is set by a URDF loader.
	attribute float m_jointMaxForce;     //todo: implement this internally. It is unused for now, it is set by a URDF loader.
	attribute float m_jointMaxVelocity;  //todo: implement this internally. It is unused for now, it is set by a URDF loader.

	// ctor: set some sensible defaults
	void btMultibodyLink();
};

interface btMultiBodyLinkCollider : btCollisionObject {
	attribute btMultiBody m_multiBody;
	attribute long m_link;

	void btMultiBodyLinkCollider(btMultiBody multiBody, long link);
  [Const] static btMultiBodyLinkCollider upcast([Const] btCollisionObject colObj);
	boolean checkCollideWithOverride([Const] btCollisionObject co);
};
btMultiBodyLinkCollider implements btCollisionObject;

interface btMultiBody {
  void btMultiBody(long n_links,               // NOT including the base
              float mass,                      // mass of base
              [Const, Ref] btVector3 inertia,  // inertia of base, in base frame; assumed diagonal
              boolean fixed_base_,             // whether the base is fixed (true) or can move (false)
              boolean can_sleep_, optional boolean deprecatedMultiDof);

	//note: fixed link collision with parent is always disabled
	void setupFixed(long i, //linkIndex
					float mass,
					[Const, Ref] btVector3 inertia,
					long parent,
					[Const, Ref] btQuaternion rotParentToThis,
					[Const, Ref] btVector3 parentComToThisPivotOffset,
					[Const, Ref] btVector3 thisPivotToThisComOffset, optional boolean deprecatedDisableParentCollision);

  void setupPrismatic(long i,             // 0 to num_links-1
                      float mass,
                      [Const, Ref] btVector3 inertia,       // in my frame; assumed diagonal
                      long parent,
                      [Const, Ref] btQuaternion rot_parent_to_this,  // rotate points in parent frame to my frame.
                      [Const, Ref] btVector3 joint_axis,             // in my frame
                      [Const, Ref] btVector3 parentComToThisPivotOffset,
                      [Const, Ref] btVector3 thisPivotToThisComOffset,
                      boolean disableParentCollision);

  void setupRevolute(long i,            // 0 to num_links-1
                      float mass,
                      [Const, Ref] btVector3 inertia,
                      long parent,
                      [Const, Ref] btQuaternion zero_rot_parent_to_this,  // rotate points in parent frame to this frame, when q = 0
                      [Const, Ref] btVector3 joint_axis,    // in my frame
                      [Const, Ref] btVector3 parent_axis_position,    // vector from parent COM to joint axis, in PARENT frame
                      [Const, Ref] btVector3 my_axis_position,       // vector from joint axis to my COM, in MY frame
                      optional boolean disableParentCollision);
	
	void setupSpherical(long i,  // linkIndex, 0 to num_links-1
						float mass,
						[Const, Ref] btVector3 inertia,
						long parent,
						[Const, Ref] btQuaternion rotParentToThis,          // rotate points in parent frame to this frame, when q = 0
						[Const, Ref] btVector3 parentComToThisPivotOffset,  // vector from parent COM to joint axis, in PARENT frame
						[Const, Ref] btVector3 thisPivotToThisComOffset,    // vector from joint axis to my COM, in MY frame
						optional boolean disableParentCollision);

	void setupPlanar(long i,  // 0 to num_links-1
					 float mass,
					 [Const, Ref] btVector3 inertia,
					 long parent,
					 [Const, Ref] btQuaternion rotParentToThis,  // rotate points in parent frame to this frame, when q = 0
					 [Const, Ref] btVector3 rotationAxis,
					 [Const, Ref] btVector3 parentComToThisComOffset,  // vector from parent COM to this COM, in PARENT frame
					 optional boolean disableParentCollision = false);

	[Const, Ref] btMultibodyLink getLink(long index);
	// [Ref] btMultibodyLink getLink(long index);

  //collider can be NULL to disable collision for the base
	void setBaseCollider(btMultiBodyLinkCollider collider);
	// [Const] btMultiBodyLinkCollider getBaseCollider();
	btMultiBodyLinkCollider getBaseCollider();

  [Const] btMultiBodyLinkCollider getLinkCollider(long index);

  //
  // get parent
  // input: link num from 0 to num_links-1
  // output: link num from 0 to num_links-1, OR -1 to mean the base.
  //
  long getParent(long link_num);
  
  //
  // get number of links, masses, moments of inertia
  //

  long getNumLinks();
	long getNumDofs();
	long getNumPosVars();
  float getBaseMass();
  [Const, Ref] btVector3 getBaseInertia();
  float getLinkMass(long i);
  [Const, Ref] btVector3 getLinkInertia(long i);
  

  //
  // change mass (incomplete: can only change base mass and inertia at present)
  //

  void setBaseMass(float mass);
  void setBaseInertia([Const, Ref] btVector3 inertia);


  //
  // get/set pos/vel/rot/omega for the base link
  //

  [Const, Ref] btVector3 getBasePos();
  [Const, Value] btVector3 getBaseVel();
  [Const, Ref] btQuaternion getWorldToBaseRot();
  [Const, Ref] btVector3 getInterpolateBasePos();
  [Const, Ref] btQuaternion getInterpolateWorldToBaseRot();
  [Value] btVector3 getBaseOmega();

  void setBasePos([Const, Ref] btVector3 pos);
  void setInterpolateBasePos([Const, Ref] btVector3 pos);
  void setBaseWorldTransform([Const, Ref] btTransform tr);
  [Value] btTransform getBaseWorldTransform();
  void setInterpolateBaseWorldTransform([Const, Ref] btTransform tr);
  [Value] btTransform getInterpolateBaseWorldTransform();
  void setBaseVel([Const, Ref] btVector3 vel);
  void setWorldToBaseRot([Const, Ref] btQuaternion rot);
  void setInterpolateWorldToBaseRot([Const, Ref] btQuaternion rot);
  void setBaseOmega([Const, Ref] btVector3 omega);

  //
  // get/set pos/vel for child links (i = 0 to num_links-1)
  //

  float getJointPos(long i);
  float getJointVel(long i);
	// [Const] float* getJointPosMultiDof(long i);
	// [Const] float* getJointVelMultiDof(long i);

	void setJointPos(long i, float q);
	void setJointVel(long i, float qdot);
	// void setJointPosMultiDof(long i, [Const] float* q);
	// void setJointVelMultiDof(long i, [Const] float* qdot);

  //
  // direct access to velocities as a vector of 6 + num_links elements.
  // (omega first, then v, then joint velocities.)
  //
  // [Const] float* getVelocityVector();

  [Const, Ref] btVector3 getRVector(long i);   // vector from COM(parent(i)) to COM(i), in frame i's coords
  [Const, Ref] btQuaternion getParentToLocalRot(long i);   // rotates vectors in frame parent(i) to vectors in frame i.
  [Const, Ref] btVector3 getInterpolateRVector(long i);
  [Const, Ref] btQuaternion getInterpolateParentToLocalRot(long i);

  [Value] btVector3 localPosToWorld(long i, [Const, Ref] btVector3 vec);
  [Value] btVector3 localDirToWorld(long i, [Const, Ref] btVector3 vec);
  [Value] btVector3 worldPosToLocal(long i, [Const, Ref] btVector3 vec);
  [Value] btVector3 worldDirToLocal(long i, [Const, Ref] btVector3 vec);

  //
	// transform a frame in local coordinate to a frame in world coordinate
	//
	[Value] btMatrix3x3 localFrameToWorld(long i, [Const, Ref] btMatrix3x3 local_frame);

  void clearForcesAndTorques();
	void clearConstraintForces();

	void clearVelocities();

  void addBaseForce([Const, Ref] btVector3 f);
  void addBaseTorque([Const, Ref] btVector3 t);
  void addLinkForce(long i, [Const, Ref] btVector3 f);
  void addLinkTorque(long i, [Const, Ref] btVector3 t);


	void addBaseConstraintForce([Const, Ref] btVector3 f);
	void addBaseConstraintTorque([Const, Ref] btVector3 t);
	void addLinkConstraintForce(long i, [Const, Ref] btVector3 f);
	void addLinkConstraintTorque(long i, [Const, Ref] btVector3 t);

	void addJointTorque(long i, float Q);
	void addJointTorqueMultiDof(long i, long dof, float Q);

	[Const, Ref] btVector3 getBaseForce();
	[Const, Ref] btVector3 getBaseTorque();
	[Const, Ref] btVector3 getLinkForce(long i);
	[Const, Ref] btVector3 getLinkTorque(long i);
	float getJointTorque(long i);
	// float* getJointTorqueMultiDof(long i);


  //
  // dynamics routines.
  //

  // timestep the velocities (given the external forces/torques set using addBaseForce etc).
  // also sets up caches for calcAccelerationDeltas.
  //
  // Note: the caller must provide three vectors which are used as
  // temporary scratch space. The idea here is to reduce dynamic
  // memory allocation: the same scratch vectors can be re-used
  // again and again for different Multibodies, instead of each
  // btMultiBody allocating (and then deallocating) their own
  // individual scratch buffers. This gives a considerable speed
  // improvement, at least on Windows (where dynamic memory
  // allocation appears to be fairly slow).
  

	void computeAccelerationsArticulatedBodyAlgorithmMultiDof(float dt,
                                                            [Ref] btScalarArray scratch_r,
                                                            [Ref] btVector3Array scratch_v,
                                                            [Ref] btMatrix3x3Array scratch_m,
                                                            boolean isConstraintPass,
                                                            boolean jointFeedbackInWorldSpace,
                                                            boolean jointFeedbackInJointFrame
                                                            );

  void setCanSleep(boolean canSleep);
	boolean getCanSleep();
	boolean getCanWakeup();
	void setCanWakeup(boolean canWakeup);
  boolean isAwake();
  void wakeUp();
  void goToSleep();
  void checkMotionAndSleepIfRequired(float timestep);
    
	boolean hasFixedBase();
	boolean isBaseKinematic();
	boolean isBaseStaticOrKinematic();
	// set the dynamic type in the base's collision flags.
	void setBaseDynamicType(long dynamicType);
	void setFixedBase(boolean fixedBase);

	long getCompanionId();
	void setCompanionId(long id);
	void setNumLinks(long numLinks); //careful: when changing the number of links, make sure to re-initialize or update existing links
	float getLinearDamping();
	void setLinearDamping(float damp);
	float getAngularDamping();
  void setAngularDamping(float damp);
	boolean getUseGyroTerm();
	void setUseGyroTerm(boolean useGyro);
  float getMaxCoordinateVelocity();
  void setMaxCoordinateVelocity(float maxVel);
	float getMaxAppliedImpulse();
	void setMaxAppliedImpulse(float maxImp);

	void setHasSelfCollision(boolean hasSelfCollision);
	boolean hasSelfCollision();

	void finalizeMultiDof();

	void useRK4Integration(boolean use);
	boolean isUsingRK4Integration();
	void useGlobalVelocities(boolean use);
	boolean isUsingGlobalVelocities();

	void setLinkDynamicType([Const] long i, long type);
	boolean isLinkStaticOrKinematic([Const] long i);
	boolean isLinkKinematic([Const] long i);
	boolean isLinkAndAllAncestorsStaticOrKinematic([Const] long i);
	boolean isLinkAndAllAncestorsKinematic([Const] long i);
	void setSleepThreshold(float sleepThreshold);
	void setSleepTimeout(float sleepTimeout);
};

interface btMultiBodyJacobianData {
	[Value] attribute btScalarArray		  m_jacobians;
	[Value] attribute btScalarArray		  m_deltaVelocitiesUnitImpulse;
	[Value] attribute btScalarArray		  m_deltaVelocities;
	[Value] attribute btScalarArray		  scratch_r;
	[Value] attribute btVector3Array		scratch_v;
	[Value] attribute btMatrix3x3Array	scratch_m;
	attribute btSolverBodyArray 	      m_solverBodyPool;
	attribute long									    m_fixedBodyId;
};

interface btMultiBodyConstraint {
	// void btMultiBodyConstraint(btMultiBody bodyA, btMultiBody bodyB,long linkA, long linkB, long numRows, boolean isUnilateral);

	long getIslandIdA();
	long getIslandIdB();
	
	// void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
	// 	[Ref] btMultiBodyJacobianData data,
	// 	[Const, Ref] btContactSolverInfo infoGlobal);

	long getNumRows();
	btMultiBody getMultiBodyA();
  btMultiBody	getMultiBodyB();

	// current constraint position
  // constraint is pos >= 0 for unilateral, or pos = 0 for bilateral
  // NOTE: ignored position for friction rows.
  float getPosition(long row);
  void setPosition(long row, float pos);

	boolean isUnilateral();

	// jacobian blocks.
  // each of size 6 + num_links. (jacobian2 is null if no body2.)
  // format: 3 'omega' coefficients, 3 'v' coefficients, then the 'qdot' coefficients.
  // float* jacobianA(long row);
  // [Const] float* jacobianA(long row);
  // float* jacobianB(long row);
  // [Const] float* jacobianB(long row);
	float	getMaxAppliedImpulse();
	void	setMaxAppliedImpulse(float maxImp);
};

interface btMultiBodyMLCPConstraintSolver : btMultiBodyConstraintSolver {
  void btMultiBodyMLCPConstraintSolver(btMLCPSolverInterface solver);
	void setMLCPSolver(btMLCPSolverInterface solver);
	long getNumFallbacks();
	void setNumFallbacks(long num);
	btConstraintSolverType getSolverType();
};
btMultiBodyMLCPConstraintSolver implements btMultiBodyConstraintSolver;

interface btMultiBodyConstraintSolver : btSequentialImpulseConstraintSolver {
  void btMultiBodyConstraintSolver();
	// void solveMultiBodyGroup(btCollisionObject* bodies, long numBodies, btPersistentManifold* manifold,long numManifolds,btTypedConstraint* constraints,long numConstraints,btMultiBodyConstraint* multiBodyConstraints, long numMultiBodyConstraints, [Const, Ref] btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher);
};
btMultiBodyConstraintSolver implements btSequentialImpulseConstraintSolver;

interface btMultiBodyDynamicsWorld : btDiscreteDynamicsWorld {
	void btMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration);
	
	void addMultiBody(btMultiBody body, short group, short mask);
	void removeMultiBody(btMultiBody body);
	void addMultiBodyConstraint( btMultiBodyConstraint constraint);
	void removeMultiBodyConstraint( btMultiBodyConstraint constraint);
};
btMultiBodyDynamicsWorld implements btDiscreteDynamicsWorld;

interface btMultiBodyFixedConstraint : btMultiBodyConstraint {
	void btMultiBodyFixedConstraint(btMultiBody bodyA, long linkA, btMultiBody bodyB, long linkB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB, [Const, Ref] btMatrix3x3 frameInA, [Const, Ref] btMatrix3x3 frameInB);
  
  void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

  [Const, Ref] btVector3 getPivotInA();
  void setPivotInA([Const, Ref] btVector3 pivotInA);
  [Const, Ref] btVector3 getPivotInB();
  void setPivotInB([Const, Ref] btVector3 pivotInB);

  [Const, Ref] btMatrix3x3 getFrameInA();
  void setFrameInA([Const, Ref] btMatrix3x3 frameInA);
  [Const, Ref] btMatrix3x3 getFrameInB();
  void setFrameInB([Const, Ref] btMatrix3x3 frameInB);
};
btMultiBodyFixedConstraint implements btMultiBodyConstraint;

interface btMultiBodyGearConstraint : btMultiBodyConstraint {
	void btMultiBodyGearConstraint(btMultiBody bodyA, long linkA, btMultiBody bodyB, long linkB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB, [Const, Ref] btMatrix3x3 frameInA, [Const, Ref] btMatrix3x3 frameInB);
  
  void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

  [Const, Ref] btVector3 getPivotInA();
  void setPivotInA([Const, Ref] btVector3 pivotInA);
  [Const, Ref] btVector3 getPivotInB();
  void setPivotInB([Const, Ref] btVector3 pivotInB);

  [Const, Ref] btMatrix3x3 getFrameInA();
  void setFrameInA([Const, Ref] btMatrix3x3 frameInA);
  [Const, Ref] btMatrix3x3 getFrameInB();
  void setFrameInB([Const, Ref] btMatrix3x3 frameInB);

	void setGearRatio(float gearRatio);
	void setGearAuxLink(long gearAuxLink);
	void setRelativePositionTarget(float relPosTarget);
	void setErp(float erp);
};
btMultiBodyGearConstraint implements btMultiBodyConstraint;

interface btMultiBodyJointLimitConstraint : btMultiBodyConstraint {
	void btMultiBodyJointLimitConstraint(btMultiBody body, long link, float lower, float upper);

  void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

	float getLowerBound();
	float getUpperBound();
	void setLowerBound(float lower);
	void setUpperBound(float upper);
};
btMultiBodyJointLimitConstraint implements btMultiBodyConstraint;

interface btMultiBodyJointMotor : btMultiBodyConstraint {
	void btMultiBodyJointMotor(btMultiBody body, long link, long linkDoF, float desiredVelocity, float maxMotorImpulse);

  void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

  void setVelocityTarget(float velTarget, optional float kd);
  void setPositionTarget(float posTarget, optional float kp);
  void setErp(float erp);
  float getErp();
  void setRhsClamp(float rhsClamp);
};
btMultiBodyJointMotor implements btMultiBodyConstraint;

interface btMultiBodyPoint2Point : btMultiBodyConstraint {
	void btMultiBodyPoint2Point(btMultiBody body, long link, btRigidBody bodyB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB);
	void btMultiBodyPoint2Point(btMultiBody bodyA, long linkA, btMultiBody bodyB, long linkB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB);

	void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

	[Const, Ref] btVector3 getPivotInB();
	void setPivotInB([Const, Ref] btVector3 pivotInB);
};
btMultiBodyPoint2Point implements btMultiBodyConstraint;

interface btMultiBodySliderConstraint : btMultiBodyConstraint {
	void btMultiBodySliderConstraint(btMultiBody body, long link, btRigidBody bodyB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB, [Const, Ref] btMatrix3x3 frameInA, [Const, Ref] btMatrix3x3 frameInB, [Const, Ref] btVector3 jointAxis);
	void btMultiBodySliderConstraint(btMultiBody bodyA, long linkA, btMultiBody bodyB, long linkB, [Const, Ref] btVector3 pivotInA, [Const, Ref] btVector3 pivotInB, [Const, Ref] btMatrix3x3 frameInA, [Const, Ref] btMatrix3x3 frameInB, [Const, Ref] btVector3 jointAxis);

	void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

	[Const, Ref] btVector3 getPivotInA();
	void setPivotInA([Const, Ref] btVector3 pivotInA);
	[Const, Ref] btVector3 getPivotInB();
	void setPivotInB([Const, Ref] btVector3 pivotInB);
	[Const, Ref] btMatrix3x3 getFrameInA();
	void setFrameInA([Const, Ref] btMatrix3x3 frameInA);
	[Const, Ref] btMatrix3x3 getFrameInB();
	void setFrameInB([Const, Ref] btMatrix3x3 frameInB);
  [Const, Ref] btVector3 getJointAxis();
  void setJointAxis([Const, Ref] btVector3 jointAxis);
};
btMultiBodySliderConstraint implements btMultiBodyConstraint;

interface btMultiBodySphericalJointLimit : btMultiBodyConstraint {
	void btMultiBodySphericalJointLimit(btMultiBody body, long link, 
		float swingxRange,
		float swingyRange,
		float twistRange,
		float maxAppliedImpulse);

	void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

  void setVelocityTarget([Const, Ref] btVector3 velTarget, optional float kd);
  void setVelocityTargetMultiDof([Const, Ref] btVector3 velTarget, [Const, Ref] optional btVector3 kd);
  void setPositionTarget([Const, Ref] btQuaternion posTarget, optional float kp);
  void setPositionTargetMultiDof([Const, Ref] btQuaternion posTarget, [Const, Ref] optional btVector3 kp);
  void setErp(float erp);
  float getErp();
  void setRhsClamp(float rhsClamp);
  float getMaxAppliedImpulseMultiDof(long i);
  void setMaxAppliedImpulseMultiDof([Const, Ref] btVector3 maxImp);
};
btMultiBodySphericalJointLimit implements btMultiBodyConstraint;

interface btMultiBodySphericalJointMotor : btMultiBodyConstraint {
	void btMultiBodySphericalJointMotor(btMultiBody body, long link, float maxMotorImpulse);

	void finalizeMultiDof();

	long getIslandIdA();
	long getIslandIdB();

	void createConstraintRows([Ref] btMultiBodyConstraintArray constraintRows,
		[Ref] btMultiBodyJacobianData data,
		[Const, Ref] btContactSolverInfo infoGlobal);

  void setVelocityTarget([Const, Ref] btVector3 velTarget, optional float kd);
  void setVelocityTargetMultiDof([Const, Ref] btVector3 velTarget, [Const, Ref] optional btVector3 kd);
  void setPositionTarget([Const, Ref] btQuaternion posTarget, optional float kp);
  void setPositionTargetMultiDof([Const, Ref] btQuaternion posTarget, [Const, Ref] optional btVector3 kp);
  void setErp(float erp);
  float getErp();
  void setRhsClamp(float rhsClamp);
  float getMaxAppliedImpulseMultiDof(long i);
  void setMaxAppliedImpulseMultiDof([Const, Ref] btVector3 maxImp);
  float getDamping(long i);
  void setDamping([Const, Ref] btVector3 damping);
};
btMultiBodySphericalJointMotor implements btMultiBodyConstraint;

interface btMultiBodySolverConstraint {
	attribute long				m_deltaVelAindex;//more generic version of m_relpos1CrossNormal/m_contactNormal1
	[Value] attribute btVector3		m_relpos1CrossNormal;
	[Value] attribute btVector3		m_contactNormal1;
	attribute long				m_jacAindex;

	attribute long				m_deltaVelBindex;
	[Value] attribute btVector3		m_contactNormal2; //usually m_contactNormal2 == -m_contactNormal1, but not always
	[Value] attribute btVector3		m_relpos2CrossNormal;
	attribute long				m_jacBindex;

	[Value] attribute btVector3		m_angularComponentA;
	[Value] attribute btVector3		m_angularComponentB;
	
	// mutable btSimdScalar	m_appliedPushImpulse;
	// mutable btSimdScalar	m_appliedImpulse;

	attribute float	m_friction;
	attribute float	m_jacDiagABInv;
	attribute float		m_rhs;
	attribute float		m_cfm;
	
  attribute float		m_lowerLimit;
	attribute float		m_upperLimit;
	attribute float		m_rhsPenetration;

	attribute long	m_overrideNumSolverIterations;
  attribute long			m_frictionIndex;

	attribute long m_solverBodyIdA;
	attribute btMultiBody m_multiBodyA;
	attribute long			m_linkA;
	
	attribute long m_solverBodyIdB;
	attribute btMultiBody m_multiBodyB;
	attribute long			m_linkB;
};

// enum btMultiBodySolverConstraint_btSolverConstraintType {
//   "btMultiBodySolverConstraint::BT_SOLVER_CONTACT_1D",
//   "btMultiBodySolverConstraint::BT_SOLVER_FRICTION_1D"
// };

interface	btMultiBodyConstraintArray {
  void btMultiBodyConstraintArray();
  long size();
  [Const, Ref] btMultiBodySolverConstraint at(long n);
  void clear();
  void pop_back();
  void resize(long newsize, [Const, Ref] btMultiBodySolverConstraint? fillData);
  [Ref] btMultiBodySolverConstraint expandNonInitializing();
  [Ref] btMultiBodySolverConstraint expand([Const, Ref] btMultiBodySolverConstraint? fillValue);
  void push_back([Const, Ref] btMultiBodySolverConstraint _Val);
  long capacity();
  void reserve(long _Count);
};

interface btMLCPSolverInterface {
	//return true is it solves the problem successfully
	// boolean solveMLCP([Const, Ref] btMatrixXu A, [Const, Ref] btVectorXu b, [Ref] btVectorXu x, [Const, Ref] btVectorXu lo, [Const, Ref] btVectorXu hi, [Const, Ref] btAlignedObjectArray<int> limitDependency, long numIterations, boolean useSparsity);
};

interface btDantzigSolver : btMLCPSolverInterface {
  void btDantzigSolver();
};
btDantzigSolver implements btMLCPSolverInterface;

interface btSolveProjectedGaussSeidel : btMLCPSolverInterface {
  void btSolveProjectedGaussSeidel();
};
btSolveProjectedGaussSeidel implements btMLCPSolverInterface;

interface btLemkeSolver : btMLCPSolverInterface {
  void btLemkeSolver();
};
btLemkeSolver implements btMLCPSolverInterface;

interface btMLCPSolver : btSequentialImpulseConstraintSolver {
	void btMLCPSolver(btMLCPSolverInterface solver);
	
	void setMLCPSolver(btMLCPSolverInterface solver);

	long getNumFallbacks();
	void setNumFallbacks(long num);

	btConstraintSolverType getSolverType();
};
btMLCPSolver implements btSequentialImpulseConstraintSolver;

// soft bodies

interface btSoftBodyWorldInfo {
  void btSoftBodyWorldInfo();
  attribute float air_density;
  attribute float water_density;
  attribute float water_offset;
  attribute float m_maxDisplacement;
  [Value] attribute btVector3 water_normal;
  attribute btBroadphaseInterface m_broadphase;
  attribute btDispatcher m_dispatcher;
  [Value] attribute btVector3 m_gravity;
};

[Prefix="btSoftBody::"]
interface Face {
  attribute Node[] m_n;
  [Value] attribute btVector3 m_normal;
  attribute float m_ra;
};

[Prefix="btSoftBody::"]
interface tFaceArray {
  [Const] long size();
  [Const, Ref] Face at(long n);
};

[Prefix="btSoftBody::"]
interface Node {
  [Value] attribute btVector3 m_x;
  [Value] attribute btVector3 m_q;
  [Value] attribute btVector3 m_v;
  [Value] attribute btVector3 m_f;
  [Value] attribute btVector3 m_n;
  attribute float m_im;
  attribute float m_area;
};

[Prefix="btSoftBody::"]
interface tNodeArray {
  [Const] long size();
  [Const, Ref] Node at(long n);
};

[Prefix="btSoftBody::"]
interface Material {
  attribute float m_kLST;
  attribute float m_kAST;
  attribute float m_kVST;
  attribute long m_flags;
};

[Prefix="btSoftBody::"]
interface tMaterialArray {
  [Const] long size();
  Material at(long n);
};

[Prefix="btSoftBody::"]
interface Anchor {
  attribute Node m_node;
  [Value] attribute btVector3 m_local;
  attribute btRigidBody m_body;
  attribute float m_influence;
  [Value] attribute btMatrix3x3 m_c0;
  [Value] attribute btVector3 m_c1;
  attribute float m_c2;
};

[Prefix="btSoftBody::"]
interface tAnchorArray {
  [Const] long size();
  [Value] Anchor at(long n);
  void clear();
  void push_back([Ref] Anchor val);
  void pop_back();
};

[Prefix="btSoftBody::"]
interface Config {
  attribute float kVCF;
  attribute float kDP;
  attribute float kDG;
  attribute float kLF;
  attribute float kPR;
  attribute float kVC;
  attribute float kDF;
  attribute float kMT;
  attribute float kCHR;
  attribute float kKHR;
  attribute float kSHR;
  attribute float kAHR;
  attribute float kSRHR_CL;
  attribute float kSKHR_CL;
  attribute float kSSHR_CL;
  attribute float kSR_SPLT_CL;
  attribute float kSK_SPLT_CL;
  attribute float kSS_SPLT_CL;
  attribute float maxvolume;
  attribute float timescale;
  attribute long viterations;
  attribute long piterations;
  attribute long diterations;
  attribute long citerations;
  attribute long collisions;
};

interface btSoftBody {
  void btSoftBody(btSoftBodyWorldInfo worldInfo, long node_count, btVector3 x, float[] m);

  [Value] attribute Config m_cfg;
  [Value] attribute tNodeArray m_nodes;
  [Value] attribute tFaceArray m_faces;
  [Value] attribute tMaterialArray m_materials;
  [Value] attribute tAnchorArray m_anchors;

  [Const] boolean checkLink( long node0, long node1);
  [Const] boolean checkFace( long node0, long node1, long node2);
  Material appendMaterial();
  void appendNode( [Const, Ref] btVector3 x, float m);
  void appendLink( long node0, long node1, Material mat, boolean bcheckexist);
  void appendFace( long node0, long node1, long node2, Material mat);
  void appendTetra( long node0, long node1, long node2, long node3, Material mat);
  void appendAnchor( long node, btRigidBody body, boolean disableCollisionBetweenLinkedBodies, float influence);
  void addForce([Const, Ref] btVector3 force);
  void addForce([Const, Ref] btVector3 force, long node);
  void addAeroForceToNode([Const, Ref] btVector3 windVelocity, long nodeIndex);
  [Const] float getTotalMass();
  void setTotalMass( float mass, boolean fromfaces);
  void setMass(long node, float mass);
  void transform( [Const, Ref] btTransform trs);
  void translate( [Const, Ref] btVector3 trs);
  void rotate( [Const, Ref] btQuaternion rot);
  void scale(  [Const, Ref] btVector3 scl);
  long generateClusters(long k, optional long maxiterations);
  long generateBendingConstraints(long distance, Material mat);
  btSoftBody upcast(btCollisionObject colObj);
  float getRestLengthScale();
  void setRestLengthScale(float restLength);
};
btSoftBody implements btCollisionObject;

interface btSoftBodyRigidBodyCollisionConfiguration {
  void btSoftBodyRigidBodyCollisionConfiguration([Ref] optional btDefaultCollisionConstructionInfo info);
};
btSoftBodyRigidBodyCollisionConfiguration implements btDefaultCollisionConfiguration;

interface btSoftBodySolver {
};

interface btDefaultSoftBodySolver {
  void btDefaultSoftBodySolver ();
};
btDefaultSoftBodySolver implements btSoftBodySolver;

interface btSoftBodyArray {
  [Const] long size();
  [Const] btSoftBody at(long n);
};

interface btSoftRigidDynamicsWorld {
  void btSoftRigidDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver);

  void addSoftBody(btSoftBody body, short collisionFilterGroup, short collisionFilterMask);
  void removeSoftBody(btSoftBody body);
  void removeCollisionObject(btCollisionObject collisionObject);

  [Ref] btSoftBodyWorldInfo getWorldInfo();
  [Ref] btSoftBodyArray getSoftBodyArray();
};
btSoftRigidDynamicsWorld implements btDiscreteDynamicsWorld;

interface btSoftBodyHelpers {
  void btSoftBodyHelpers();

  btSoftBody CreateRope([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 from, [Const, Ref] btVector3 to, long res, long fixeds);
  btSoftBody CreatePatch([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 corner00, [Const, Ref] btVector3 corner10, [Const, Ref] btVector3 corner01, [Const, Ref] btVector3 corner11, long resx, long resy, long fixeds, boolean gendiags);
  btSoftBody CreatePatchUV([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 corner00, [Const, Ref] btVector3 corner10, [Const, Ref] btVector3 corner01, [Const, Ref] btVector3 corner11, long resx, long resy, long fixeds, boolean gendiags, float[] tex_coords);
  btSoftBody CreateEllipsoid([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 center, [Const, Ref] btVector3 radius, long res);
  btSoftBody CreateFromTriMesh([Ref] btSoftBodyWorldInfo worldInfo, float[] vertices, long[] triangles, long ntriangles, boolean randomizeConstraints);
  btSoftBody CreateFromConvexHull([Ref] btSoftBodyWorldInfo worldInfo, [Const] btVector3 vertices, long nvertices, boolean randomizeConstraints);
};