ammo.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 setAnisotropicFriction([Const, Ref] btVector3 anisotropicFriction, long frictionMode);
  btCollisionShape getCollisionShape();
  void setContactProcessingThreshold(float contactProcessingThreshold);
  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();
  void setRestitution(float rest);
  void setFriction(float frict);
  void setRollingFriction(float frict);
  [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);
  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 short m_collisionFilterGroup;
  attribute short 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;

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 {
  long size();
  [Const, Ref] btVector3 at(long n);
};

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

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

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);
  [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();
  void clearForces();
};
btRigidBody implements btCollisionObject;

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

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

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

interface btDynamicsWorld {
  void addAction(btActionInterface action);
  void removeAction(btActionInterface action);
  [Ref] btContactSolverInfo getSolverInfo();
  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);

	// Contact callback support
  void setContactAddedCallback(long funcpointer);
  void setContactProcessedCallback(long funcpointer);
  void setContactDestroyedCallback(long funcpointer);
};
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, 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);
};
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();
};


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