ammo.release.idl

// 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(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 rotate([Ref] btVector3 wAxis, float angle);
  // float dot([Ref] btVector3 v);
  // [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();
//   void setValue(float x, float y, float z, float w);
// };
// 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(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);
};

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

// Collision

interface btCollisionObject {
  void btCollisionObject();
  // void setAnisotropicFriction([Const, Ref] btVector3 anisotropicFriction, long frictionMode);
  btCollisionShape getCollisionShape();
  // void setContactProcessingThreshold(float contactProcessingThreshold);  
  long getActivationState();
  void setActivationState(long newState);
  void forceActivationState(long newState);
  void activate(optional boolean forceActivation);
  boolean isActive();
  boolean isKinematicObject();
  boolean isStaticObject();
  boolean isStaticOrKinematicObject();
  // [Const] float getRestitution();
  // [Const] float getFriction();
  // [Const] float getRollingFriction();
  // [Const] float getSpinningFriction();
  void setRestitution(float r);
  void setFriction(float f);
  void setRollingFriction(float rf);
  void setSpinningFriction(float sf);
  [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();
  void setUserIndex(long index);
  void setUserIndex2(long index);
  // VoidPtr getUserPointer();
  // void setUserPointer(VoidPtr userPointer);
  // [Const] btBroadphaseProxy getBroadphaseHandle();
  // boolean checkCollideWith([Const] btCollisionObject co);
  void setIgnoreCollisionCheck([Const] btCollisionObject co, boolean ig);
  void setInterpolationWorldTransform([Const,Ref] btTransform trans);
  [Ref] btTransform getInterpolationWorldTransform();
};

// [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;
};

[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;

[Prefix="cc::"]
interface ccClosestRayResultCallback {
  void ccClosestRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);
  // attribute long m_shapeUserPointer;
  // attribute boolean m_queryTrigger;
  [Ref] btVector3 getHitNormalWorld();
  [Ref] btVector3 getHitPointWorld();
  long getCollisionShapePtr();
  float getClosestHitFraction();
  void reset(long mask, boolean queryTrigger);
};
ccClosestRayResultCallback implements ClosestRayResultCallback;

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

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

[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;

[Prefix="cc::"]
interface ccAllHitsRayResultCallback {
  void ccAllHitsRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);
  // [Value] attribute btIntArray m_shapeParts;
  [Ref] btScalarArray getHitFractions();
  [Ref] btVector3Array getHitNormalWorld();
  [Ref] btVector3Array getHitPointWorld();
  [Ref] btIntArray getCollisionShapePtrs();
  void reset(long mask, boolean queryTrigger);
};
ccAllHitsRayResultCallback implements AllHitsRayResultCallback;

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_positionWorldOnA;
  [Value] attribute btVector3 m_positionWorldOnB;
  [Value] attribute btVector3 m_normalWorldOnB;
  
  attribute double m_distance1;
	// attribute double m_combinedFriction;
	// attribute double m_combinedRollingFriction;
	// attribute double m_combinedRestitution;

  //BP mod, store contact triangles.
  // attribute long m_partId0;
  // attribute	long m_partId1;
  attribute	long m_index0;
  attribute	long m_index1;

  // Contact callback support
  // attribute any m_userPersistentData;
  // attribute long m_userPersistentData0;
  // attribute long m_userPersistentData1;
  
	//// XXX +++
  [Const] btCollisionShape getShape0();
  [Const] btCollisionShape getShape1();
};

// [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 long m_collisionFilterGroup;
//   attribute long m_collisionFilterMask;
//   attribute float m_closestHitFraction;
// };

// [Prefix="btCollisionWorld::"]
// interface ClosestConvexResultCallback {
//   void ClosestConvexResultCallback([Const, Ref] btVector3 convexFromWorld, [Const, Ref] btVector3 convexToWorld);

//   [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();
  boolean isCompound();
  // VoidPtr getUserPointer();
  // void setUserPointer(VoidPtr userPointer);
  long getUserIndex();
  void setUserIndex(long index);
  long getUserPointerAsInt();
  void setUserPointerAsInt(long index);
  void getAabb([Const, Ref] btTransform t, [Ref] btVector3 min, [Ref] btVector3 max);
  
  ///XXX
  float getLocalBoundingSphere();
};

interface btConvexShape {
};
btConvexShape implements btCollisionShape;

interface btConvexInternalShape {
  [Const, Ref] btVector3 getImplicitShapeDimensions();
};
btConvexInternalShape implements btConvexShape;

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();

  // XXX
  void setUnscaledHalfExtents([Ref] btVector3 boxHalfExtents);
};
btBoxShape implements btCollisionShape;

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

  // XXX
  void updateProp(float r, float h, long upAxis);
};
btBoxShape 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();
  // long getUpAxis();

  // XXX
  void updateProp(float r, float h, long upAxis);
};
btCylinderShape implements btConvexInternalShape;

// 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();
  void setUnscaledRadius(float radius);
};
btSphereShape implements btConvexInternalShape;

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

interface btConeShape {
  void btConeShape(float radius, float height);
  void setRadius(float radius);
  void setHeight(float height);
  void setConeUpIndex(long upIndex);
};
btConeShape implements btConvexInternalShape;

interface btBU_Simplex1to4 {
  void btBU_Simplex1to4();
  void addVertex([Ref] btVector3 pt);
};
btBU_Simplex1to4 implements btConvexShape;

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

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

interface btVector3Array {
  long size();
  [Const, Ref] btVector3 at(long n);
  void clear();
};

// interface btFaceArray {
//   long size();
//   [Const, Ref] btFace at(long n);
// };

// 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 btConeShapeX {
//   void btConeShapeX(float radius, float height);
// };
// btConeShapeX implements btConeShape;

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

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();
  
  ///XXX
  //void setMaterial(long childShapeindex, float f, float r, optional float rf, optional float sf);
};
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;

interface btConcaveShape {
};
btConcaveShape implements btCollisionShape;

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

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

  ///XXX
  void setPlaneConstant(float v);
};
btStaticPlaneShape implements btConcaveShape;

interface btTriangleMeshShape {
};
btTriangleMeshShape implements btConcaveShape;

interface btBvhTriangleMeshShape {
  void btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, boolean useQuantizedAabbCompression, optional boolean buildBvh);
};
btBvhTriangleMeshShape implements btTriangleMeshShape;

// interface btGImpactShapeInterface {
// 	// void btGImpactShapeInterface();
//   void updateBound();
// };
// btGImpactShapeInterface implements btConcaveShape;

// interface btGImpactMeshShapePart {
// 	void btGImpactMeshShapePart();
//   void btGImpactMeshShapePart(btStridingMeshInterface meshInterface, long part );
// };
// btGImpactMeshShapePart implements btGImpactShapeInterface;

// interface btGImpactMeshShape {
// 	void btGImpactMeshShape(btStridingMeshInterface meshInterface);
// };
// btGImpactMeshShape implements btGImpactShapeInterface;

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

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;

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);
  void setDispatcherFlags(long flags);
};
btCollisionDispatcher implements btDispatcher;

// interface btOverlappingPairCallback {
// };

// interface btOverlapFilterCallback {
// };

// interface ccOverlapFilterCallback {
//   void ccOverlapFilterCallback();
// };
// ccOverlapFilterCallback implements btOverlapFilterCallback;

interface btOverlappingPairCache {
  // void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback);
  // void setOverlapFilterCallback(btOverlapFilterCallback cb);
  // [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_spinningFriction;
  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);
  [Const] float getLinearSleepingThreshold();
  // [Const] float getLinearDamping();
  // [Const] float getAngularDamping();
  void setDamping(float lin_damping, float ang_damping);
  void setMassProps(float mass, [Const, Ref] btVector3 inertia);
  [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 applyTorqueImpulse([Const, Ref] btVector3 torque);
  void applyImpulse([Const, Ref] btVector3 impulse, [Const, Ref] btVector3 rel_pos);
  // void applyCentralImpulse([Const, Ref] btVector3 impulse);
  void updateInertiaTensor();
  [Const, Ref] btVector3 getLinearVelocity();
  [Const, Ref] btVector3 getAngularVelocity();
  void setLinearVelocity([Const, Ref] btVector3 lin_vel);
  void setAngularVelocity([Const, Ref] btVector3 ang_vel);
  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();
  // [Const, Ref] btVector3 getGravity();
  void setGravity([Const, Ref] btVector3 acceleration);
  // [Const] btBroadphaseProxy getBroadphaseProxy();
  [Const] long getFlags();
  void setFlags(long flags);
  boolean wantsSleeping();
  void clearForces();
  [Const, Ref] btVector3 getTotalForce();
  [Const, Ref] btVector3 getTotalTorque();

  ///XXX
  void clearState();
};
btRigidBody implements btCollisionObject;

// constraint

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


interface btTypedConstraint {
  void enableFeedback(boolean needsFeedback);
  [Const] float getBreakingImpulseThreshold();
  void setBreakingImpulseThreshold([Const] float threshold);
  [Const] float getParam(long num, long axis);
  void setParam(long num, float value, long axis);
};

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 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);

  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);

  void setFrames([Const,Ref] btTransform frameA, [Const,Ref] btTransform frameB);
  void setAxis([Ref] btVector3 axisInA);
  void setUseReferenceFrameA(boolean urfa);
};
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);
//   void setLowerLinLimit(float lowerLimit);
//   void setUpperLinLimit(float upperLimit);
//   void setLowerAngLimit(float lowerAngLimit);
//   void setUpperAngLimit(float upperAngLimit);
// };
// btSliderConstraint implements btTypedConstraint;

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

// solver dispather world

interface btSequentialImpulseConstraintSolver {
  void btSequentialImpulseConstraintSolver();
};

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);
  void rayTestSingle([Const, Ref] btTransform rayFromTrans, [Const, Ref] btTransform rayToTrans, btCollisionObject collisionObject, [Const] btCollisionShape collisionShape, [Const, Ref] btTransform colObjWorldTransform, [Ref] RayResultCallback resultCallback);
  // btOverlappingPairCache getPairCache();
  // [Ref] btDispatcherInfo getDispatchInfo();
  void addCollisionObject(btCollisionObject collisionObject, optional long collisionFilterGroup, optional long 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);
  void setContactBreakingThreshold(float b);
};

// interface btContactSolverInfo {
  // attribute boolean m_splitImpulse;
  // attribute long m_splitImpulsePenetrationThreshold;
  // attribute long m_numIterations;
// };

interface btDynamicsWorld {
  void addAction(btActionInterface action);
  void removeAction(btActionInterface action);
  // [Ref] btContactSolverInfo getSolverInfo();
  [Ref] btRigidBody getFixedBody();
};
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, long group, long 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);

	// Contact callback support
  // // void setContactAddedCallback(long funcpointer);
  // void setContactProcessedCallback(long funcpointer);
  // void setContactDestroyedCallback(long funcpointer);
};
btDiscreteDynamicsWorld implements btDynamicsWorld;

[Prefix="cc::"]
interface ccDiscreteDynamicsWorld {
  void ccDiscreteDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration);
  void setAllowSleep(boolean v);
  void setDeactivationTime(float v);
  void setNarrowPhaseMethod(long v);
  void setAllowCcdPenetration(float v);
  //void setCcdCastCheckResponse(boolean v);
  //[Ref] btIntArray getCcdTriggerRecorder();
};
ccDiscreteDynamicsWorld implements btDiscreteDynamicsWorld;

// // vehicle

// [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 upAxis);

//   void setUp ([Const,Ref] btVector3 upAxis);
//   void setWalkDirection ([Const,Ref] btVector3 walkDirection);
//   void setVelocityForTimeInterval ([Const,Ref] btVector3 velocity, float timeInterval);
//   void reset (btCollisionWorld collisionWorld);
//   void warp ([Const, Ref]btVector3 origin);
//   void preStep (btCollisionWorld collisionWorld);
//   void playerStep (btCollisionWorld collisionWorld, float dt);
//   void setFallSpeed (float fallSpeed);
//   void setJumpSpeed (float jumpSpeed);
//   void setMaxJumpHeight (float maxJumpHeight);
//   boolean canJump ();
//   void jump ([Const,Ref] optional btVector3 v);
//   void setGravity ([Const, Ref] btVector3 gravity);
//   [Value] btVector3 getGravity ();
//   void setMaxSlope (float slopeRadians);
//   float getMaxSlope ();
//   btPairCachingGhostObject getGhostObject ();
//   void setUseGhostSweepTest (boolean useGhostObjectSweepTest);
//   boolean onGround ();
//   void setUpInterpolate (boolean value);
// };
// btKinematicCharacterController implements btActionInterface;

// interface ccKinematicCharacterController {
//   void ccKinematicCharacterController(btPairCachingGhostObject ghostObject, btConvexShape convexShape, float stepHeight, optional long upAxis);

//   void setUpAxis (long axis);
//   void setWalkDirection ([Const,Ref] btVector3 walkDirection);
//   void setVelocityForTimeInterval ([Const,Ref] btVector3 velocity, float timeInterval);
//   //void reset ();
//   void warp ([Const, Ref]btVector3 origin);
//   void preStep (btCollisionWorld collisionWorld);
//   void playerStep (btCollisionWorld collisionWorld, float dt);
//   void setFallSpeed (float fallSpeed);
//   void setJumpSpeed (float jumpSpeed);
//   void setMaxJumpHeight (float maxJumpHeight);
//   boolean canJump ();
//   void jump ();
//   void setGravity (float gravity);
//   float getGravity ();
//   void setMaxSlope (float slopeRadians);
//   float getMaxSlope ();
//   btPairCachingGhostObject getGhostObject ();
//   void setUseGhostSweepTest (boolean useGhostObjectSweepTest);
//   boolean onGround ();
//   void setUpInterpolate (boolean value);
// };
// ccKinematicCharacterController 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;

// ghost object

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

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

// interface btGhostPairCallback {
//   void btGhostPairCallback();
// };


// // 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 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 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);
// };
// 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, long collisionFilterGroup, long 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);
// };