// Linear Math

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

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

[NoDelete]
interface btCollisionObjectWrapper {
};

[Prefix="btCollisionWorld::"]
interface RayResultCallback {
	// abstract base class, no constructor
	boolean hasHit();
	attribute short m_collisionFilterGroup;
	attribute short m_collisionFilterMask;
	[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 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;
};

[Prefix="btCollisionWorld::"]
interface ContactResultCallback {
	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);

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

interface btConvexHullShape {
	void btConvexHullShape();
	void addPoint([Const, Ref] btVector3 point, optional boolean recalculateLocalAABB);
	void setMargin(float margin);
	float getMargin();
};
btConvexHullShape 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 btCompoundShape {
	void btCompoundShape(optional boolean enableDynamicAabbTree);
	void addChildShape([Const, Ref] btTransform localTransform, btCollisionShape shape);
	void removeChildShapeByIndex(long childShapeindex);
	[Const] long getNumChildShapes();
	btCollisionShape getChildShape(long index);
	void setMargin(float margin);
	float getMargin();
};
btCompoundShape implements btCollisionShape;

interface btStridingMeshInterface {
};

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);
};
btTriangleMesh implements btStridingMeshInterface;

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

interface btConcaveShape {
};
btConcaveShape implements btCollisionShape;

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 btGImpactMeshShape {
  void btGImpactMeshShape(btStridingMeshInterface meshInterface);
  void updateBound();
  void registerAlgorithm(btCollisionDispatcher dispatcher);
};
btGImpactMeshShape implements btConcaveShape;

interface btDefaultCollisionConstructionInfo {
	void btDefaultCollisionConstructionInfo();
};

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

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

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

interface btBroadphaseInterface {
};

interface btCollisionConfiguration {
};

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

// 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);
	void setDamping(float lin_damping, float ang_damping);
	void setMassProps(float mass, [Const, Ref] btVector3 inertia);
	void setLinearFactor([Const, Ref] btVector3 linearFactor);
	void applyTorque([Const, Ref] btVector3 torque);
	void applyForce([Const, Ref] btVector3 force, [Const, Ref] btVector3 rel_pos);
	void applyCentralForce([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);
	void setAngularFactor([Const, Ref] btVector3 angularFactor);
	btRigidBody upcast([Const] btCollisionObject colObj);
	void getAabb([Ref] btVector3 aabbMin, [Ref] btVector3 aabbMax);
	[Const, Ref] btVector3 getGravity();
	void setGravity([Const, Ref] btVector3 acceleration);
};
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);
	[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);
};
btGeneric6DofSpringConstraint implements btGeneric6DofConstraint;

interface btSequentialImpulseConstraintSolver {
	void btSequentialImpulseConstraintSolver();
};

btSequentialImpulseConstraintSolver implements btConstraintSolver;

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);
	[Const] btBroadphaseInterface getBroadphase ();
	void convexSweepTest([Const] btConvexShape castShape, [Const, Ref] btTransform from, [Const, Ref] btTransform to, [Ref] ConvexResultCallback resultCallback, float allowedCcdPenetration);
	void contactPairTest([Const] btCollisionObject colObjA, [Const] btCollisionObject colObjB, [Ref] ContactResultCallback resultCallback);
	void contactTest([Const] btCollisionObject colObj, [Ref] ContactResultCallback resultCallback);
	void updateSingleAabb(btCollisionObject colObj);
	void debugDrawWorld();
};

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

interface btDynamicsWorld {
	void addAction(btActionInterface action);
	void removeAction(btActionInterface action);
	[Ref] btContactSolverInfo getSolverInfo();
};
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::"]
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, [Const, 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 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 ([Const,Ref] btVector3 gravity);
	[Value] btVector3 getGravity ();
	void setMaxSlope (float slopeRadians);
	float getMaxSlope ();
	btPairCachingGhostObject getGhostObject ();
	void setUseGhostSweepTest (boolean useGhostObjectSweepTest);
	boolean onGround ();
};
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 Node {
	[Value] attribute btVector3 m_x;
	[Value] attribute btVector3 m_n;
};


[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 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);
	void btSoftBody(btSoftBodyWorldInfo worldInfo);
	[Value] attribute Config m_cfg;
	[Value] attribute tNodeArray m_nodes;
	[Value] attribute tMaterialArray m_materials;

	[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 updateBounds();
	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);
	[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);
	btSoftBody upcast([Const] 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);
};

interface btFloatArray {
	attribute float[] raw;
	void btFloatArray(long num);
	[Const] long size();
	[Const] float at(long n);
	[Const] long set(long n, float value);
};

interface btIntArray {
	attribute long[] raw;
	void btIntArray(long num);
	[Const] long size();
	[Const] long at(long n);
	[Const] long set(long n, long value);
};