Skip to content
Permalink
main
Switch branches/tags

ammo.js/ammo.idl

Go to file
 
 
Cannot retrieve contributors at this time
1266 lines (1102 sloc) 45 KB
Raw Blame
// 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;
attribute unsigned long m_flags;
};
[Prefix="btCollisionWorld::"]
interface ClosestRayResultCallback {
void ClosestRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);
[Value] attribute btVector3 m_rayFromWorld;
[Value] attribute btVector3 m_rayToWorld;
[Value] attribute btVector3 m_hitNormalWorld;
[Value] attribute btVector3 m_hitPointWorld;
};
ClosestRayResultCallback implements RayResultCallback;
interface btConstCollisionObjectArray {
long size();
[Const] btCollisionObject at(long n);
};
interface btScalarArray {
long size();
float at(long n);
};
[Prefix="btCollisionWorld::"]
interface AllHitsRayResultCallback {
void AllHitsRayResultCallback([Const, Ref] btVector3 from, [Const, Ref] btVector3 to);
[Value] attribute btConstCollisionObjectArray m_collisionObjects;
[Value] attribute btVector3 m_rayFromWorld;
[Value] attribute btVector3 m_rayToWorld;
[Value] attribute btVector3Array m_hitNormalWorld;
[Value] attribute btVector3Array m_hitPointWorld;
[Value] attribute btScalarArray m_hitFractions;
};
AllHitsRayResultCallback implements RayResultCallback;
interface btManifoldPoint {
[Const, Ref] btVector3 getPositionWorldOnA();
[Const, Ref] btVector3 getPositionWorldOnB();
[Const] double getAppliedImpulse();
[Const] double getDistance();
[Value] attribute btVector3 m_localPointA;
[Value] attribute btVector3 m_localPointB;
[Value] attribute btVector3 m_positionWorldOnB;
[Value] attribute btVector3 m_positionWorldOnA;
[Value] attribute btVector3 m_normalWorldOnB;
// Contact callback support
attribute any m_userPersistentData;
};
[Prefix="btCollisionWorld::"]
interface ContactResultCallback {
float addSingleResult([Ref] btManifoldPoint cp, [Const] btCollisionObjectWrapper colObj0Wrap, long partId0, long index0, [Const] btCollisionObjectWrapper colObj1Wrap, long partId1, long index1);
};
[JSImplementation="ContactResultCallback"]
interface ConcreteContactResultCallback {
void ConcreteContactResultCallback();
float addSingleResult([Ref] btManifoldPoint cp, [Const] btCollisionObjectWrapper colObj0Wrap, long partId0, long index0, [Const] btCollisionObjectWrapper colObj1Wrap, long partId1, long index1);
};
[Prefix="btCollisionWorld::"]
interface LocalShapeInfo {
attribute long m_shapePart;
attribute long m_triangleIndex;
};
[Prefix="btCollisionWorld::"]
interface LocalConvexResult {
void LocalConvexResult([Const] btCollisionObject hitCollisionObject, LocalShapeInfo localShapeInfo, [Const, Ref] btVector3 hitNormalLocal, [Const, Ref] btVector3 hitPointLocal, float hitFraction);
[Const] attribute btCollisionObject m_hitCollisionObject;
attribute LocalShapeInfo m_localShapeInfo;
[Value] attribute btVector3 m_hitNormalLocal;
[Value] attribute btVector3 m_hitPointLocal;
attribute float m_hitFraction;
};
[Prefix="btCollisionWorld::"]
interface ConvexResultCallback {
// abstract base class, no constructor
boolean hasHit();
attribute short m_collisionFilterGroup;
attribute short m_collisionFilterMask;
attribute float m_closestHitFraction;
};
[Prefix="btCollisionWorld::"]
interface ClosestConvexResultCallback {
void ClosestConvexResultCallback([Const, Ref] btVector3 convexFromWorld, [Const, Ref] btVector3 convexToWorld);
[Const] attribute btCollisionObject m_hitCollisionObject;
[Value] attribute btVector3 m_convexFromWorld;
[Value] attribute btVector3 m_convexToWorld;
[Value] attribute btVector3 m_hitNormalWorld;
[Value] attribute btVector3 m_hitPointWorld;
};
ClosestConvexResultCallback implements ConvexResultCallback;
interface btCollisionShape {
void setLocalScaling([Const, Ref] btVector3 scaling);
[Const, Ref] btVector3 getLocalScaling();
void calculateLocalInertia(float mass, [Ref] btVector3 inertia);
void setMargin(float margin);
float getMargin();
};
interface btConvexShape {
};
btConvexShape implements btCollisionShape;
interface btConvexTriangleMeshShape {
void btConvexTriangleMeshShape(btStridingMeshInterface meshInterface, optional boolean calcAabb);
};
btConvexTriangleMeshShape implements btConvexShape;
interface btBoxShape {
void btBoxShape([Ref] btVector3 boxHalfExtents);
void setMargin(float margin);
float getMargin();
};
btBoxShape implements btCollisionShape;
interface btCapsuleShape {
void btCapsuleShape(float radius, float height);
void setMargin(float margin);
float getMargin();
long getUpAxis();
float getRadius();
float getHalfHeight();
};
btCapsuleShape implements btCollisionShape;
interface btCapsuleShapeX {
void btCapsuleShapeX(float radius, float height);
void setMargin(float margin);
float getMargin();
};
btCapsuleShapeX implements btCapsuleShape;
interface btCapsuleShapeZ {
void btCapsuleShapeZ(float radius, float height);
void setMargin(float margin);
float getMargin();
};
btCapsuleShapeZ implements btCapsuleShape;
interface btCylinderShape {
void btCylinderShape([Ref] btVector3 halfExtents);
void setMargin(float margin);
float getMargin();
};
btCylinderShape implements btCollisionShape;
interface btCylinderShapeX {
void btCylinderShapeX([Ref] btVector3 halfExtents);
void setMargin(float margin);
float getMargin();
};
btCylinderShapeX implements btCylinderShape;
interface btCylinderShapeZ {
void btCylinderShapeZ([Ref] btVector3 halfExtents);
void setMargin(float margin);
float getMargin();
};
btCylinderShapeZ implements btCylinderShape;
interface btSphereShape {
void btSphereShape(float radius);
void setMargin(float margin);
float getMargin();
};
btSphereShape implements btCollisionShape;
interface btMultiSphereShape {
void btMultiSphereShape([Const] btVector3 positions, [Const] float[] radii, long numPoints);
};
btMultiSphereShape implements btCollisionShape;
interface btConeShape {
void btConeShape(float radius, float height);
};
btConeShape implements btCollisionShape;
interface btConeShapeX {
void btConeShapeX(float radius, float height);
};
btConeShapeX implements btConeShape;
interface btConeShapeZ {
void btConeShapeZ(float radius, float height);
};
btConeShapeZ implements btConeShape;
interface btIntArray {
long size();
long at(long n);
};
interface btFace {
[Value] attribute btIntArray m_indices;
attribute float[] m_plane;
};
interface btVector3Array {
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;
// GImpact
interface btAABB {
void btAABB([ Const, Ref ] btVector3 V1, [ Const, Ref ] btVector3 V2, [ Const, Ref ] btVector3 V3, float margin);
void invalidate();
void increment_margin(float margin);
void copy_with_margin([ Const, Ref ] btAABB other, float margin);
};
interface btPrimitiveTriangle {
void btPrimitiveTriangle();
};
interface btTriangleShapeEx {
void btTriangleShapeEx([ Const, Ref ] btVector3 p1, [ Const, Ref ] btVector3 p2, [ Const, Ref ] btVector3 p3);
void getAabb([ Const, Ref ] btTransform t, [ Ref ] btVector3 aabbMin, [ Ref ] btVector3 aabbMax);
void applyTransform([ Const, Ref ] btTransform t);
void buildTriPlane([ Ref ] btVector4 plane);
};
interface btPrimitiveManagerBase {
boolean is_trimesh();
long get_primitive_count();
void get_primitive_box(long prim_index , [Ref] btAABB primbox);
void get_primitive_triangle(long prim_index, [Ref] btPrimitiveTriangle triangle);
};
enum eGIMPACT_SHAPE_TYPE {
"CONST_GIMPACT_COMPOUND_SHAPE",
"CONST_GIMPACT_TRIMESH_SHAPE_PART",
"CONST_GIMPACT_TRIMESH_SHAPE"
};
interface btTetrahedronShapeEx {
void btTetrahedronShapeEx();
void setVertices([ Const, Ref ] btVector3 v0, [ Const, Ref ] btVector3 v1, [ Const, Ref ] btVector3 v2, [ Const, Ref ] btVector3 v3);
};
interface btGImpactShapeInterface {
void updateBound();
void postUpdate();
long getShapeType();
[Const] DOMString getName();
eGIMPACT_SHAPE_TYPE getGImpactShapeType();
[Const] btPrimitiveManagerBase getPrimitiveManager();
long getNumChildShapes();
boolean childrenHasTransform();
boolean needsRetrieveTriangles();
boolean needsRetrieveTetrahedrons();
void getBulletTriangle(long prim_index, [Ref] btTriangleShapeEx triangle);
void getBulletTetrahedron(long prim_index, [Ref] btTetrahedronShapeEx tetrahedron);
[Const] btCollisionShape getChildShape(long index);
[Value] btTransform getChildTransform(long index);
void setChildTransform(long index, [Const, Ref] btTransform transform);
};
btGImpactShapeInterface implements btConcaveShape;
[Prefix="btGImpactCompoundShape::"]
interface CompoundPrimitiveManager {
attribute btGImpactCompoundShape m_compoundShape;
long get_primitive_count();
void get_primitive_box(long prim_index, [Ref] btAABB primbox);
void get_primitive_triangle(long prim_index, [Ref] btPrimitiveTriangle triangle);
};
CompoundPrimitiveManager implements btPrimitiveManagerBase;
interface btGImpactCompoundShape {
void btGImpactCompoundShape(optional boolean children_has_transform = true);
boolean childrenHasTransform();
[Const] btPrimitiveManagerBase getPrimitiveManager();
CompoundPrimitiveManager getCompoundPrimitiveManager();
long getNumChildShapes();
void addChildShape([ Const, Ref ] btTransform localTransform, btCollisionShape shape);
btCollisionShape getChildShape(long index);
void getChildAabb(long child_index, [ Const, Ref ] btTransform t, [Ref] btVector3 aabbMin, [Ref] btVector3 aabbMax);
[Value] btTransform getChildTransform(long index);
void setChildTransform(long index, [ Const, Ref ] btTransform transform);
void calculateLocalInertia(float mass, [Ref] btVector3 inertia);
[Const] DOMString getName();
eGIMPACT_SHAPE_TYPE getGImpactShapeType();
};
btGImpactCompoundShape implements btGImpactShapeInterface;
[Prefix = "btGImpactMeshShapePart::"]
interface TrimeshPrimitiveManager {
attribute float m_margin;
attribute btStridingMeshInterface m_meshInterface;
attribute long m_part;
attribute long m_lock_count;
attribute long numverts;
attribute PHY_ScalarType type;
attribute long stride;
attribute long indexstride;
attribute long numfaces;
attribute PHY_ScalarType indicestype;
void TrimeshPrimitiveManager([Const, Ref] optional TrimeshPrimitiveManager manager);
void lock();
void unlock();
boolean is_trimesh();
long get_vertex_count();
void get_indices(long face_index, unsigned long i0, unsigned long i1, unsigned long i2);
void get_vertex(unsigned long vertex_index, [Ref] btVector3 vertex);
void get_bullet_triangle(long prim_index, [Ref] btTriangleShapeEx triangle);
};
TrimeshPrimitiveManager implements btPrimitiveManagerBase;
interface btGImpactMeshShapePart {
void btGImpactMeshShapePart(btStridingMeshInterface meshInterface, long part);
TrimeshPrimitiveManager getTrimeshPrimitiveManager();
long getVertexCount();
void getVertex(long vertex_index, [Ref] btVector3 vertex);
long getPart();
};
btGImpactMeshShapePart implements btGImpactShapeInterface;
interface btGImpactMeshShape {
void btGImpactMeshShape(btStridingMeshInterface meshInterface);
[Const] btStridingMeshInterface getMeshInterface();
long getMeshPartCount();
[Const] btGImpactMeshShapePart getMeshPart(long index);
long calculateSerializeBufferSize();
};
btGImpactMeshShape implements btGImpactShapeInterface;
interface btCollisionAlgorithmConstructionInfo {
void btCollisionAlgorithmConstructionInfo();
void btCollisionAlgorithmConstructionInfo(btDispatcher dispatcher, long temp);
attribute btDispatcher m_dispatcher1;
attribute btPersistentManifold m_manifold;
};
interface btCollisionAlgorithm {
};
interface btActivatingCollisionAlgorithm {
};
btActivatingCollisionAlgorithm implements btCollisionAlgorithm;
interface btGImpactCollisionAlgorithm {
void btGImpactCollisionAlgorithm([Const, Ref] btCollisionAlgorithmConstructionInfo ci, [Const] btCollisionObjectWrapper body0Wrap, [Const] btCollisionObjectWrapper body1Wrap);
static void registerAlgorithm(btCollisionDispatcher dispatcher);
};
btGImpactCollisionAlgorithm implements btActivatingCollisionAlgorithm;
//
interface btDefaultCollisionConstructionInfo {
void btDefaultCollisionConstructionInfo();
};
interface btDefaultCollisionConfiguration {
void btDefaultCollisionConfiguration([Ref] optional btDefaultCollisionConstructionInfo info);
};
interface btPersistentManifold {
void btPersistentManifold();
[Const] btCollisionObject getBody0();
[Const] btCollisionObject getBody1();
long getNumContacts();
[Ref] btManifoldPoint getContactPoint(long index);
};
interface btDispatcher {
long getNumManifolds();
btPersistentManifold getManifoldByIndexInternal(long index);
};
interface btCollisionDispatcher {
void btCollisionDispatcher(btDefaultCollisionConfiguration conf);
};
btCollisionDispatcher implements btDispatcher;
interface btOverlappingPairCallback {
};
interface btOverlappingPairCache {
void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback);
[Const] float getNumOverlappingPairs();
};
interface btAxisSweep3 {
void btAxisSweep3([Ref] btVector3 worldAabbMin, [Ref] btVector3 worldAabbMax, optional long maxHandles, optional btOverlappingPairCache pairCache, optional boolean disableRaycastAccelerator);
};
interface btBroadphaseInterface {
btOverlappingPairCache getOverlappingPairCache();
};
interface btCollisionConfiguration {
};
interface btDbvtBroadphase {
void btDbvtBroadphase();
};
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);
void setPoweredLinMotor(boolean onOff);
void setMaxLinMotorForce(float maxLinMotorForce);
void setTargetLinMotorVelocity(float targetLinMotorVelocity);
};
btSliderConstraint implements btTypedConstraint;
interface btFixedConstraint {
void btFixedConstraint([Ref] btRigidBody rbA, [Ref] btRigidBody rbB, [Const,Ref] btTransform frameInA, [Const,Ref] btTransform frameInB);
};
btFixedConstraint implements btTypedConstraint;
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);
float getRestLengthScale();
void setRestLengthScale(float restLength);
};
btSoftBody implements btCollisionObject;
interface btSoftBodyRigidBodyCollisionConfiguration {
void btSoftBodyRigidBodyCollisionConfiguration([Ref] optional btDefaultCollisionConstructionInfo info);
};
btSoftBodyRigidBodyCollisionConfiguration implements btDefaultCollisionConfiguration;
interface btSoftBodySolver {
};
interface btDefaultSoftBodySolver {
void btDefaultSoftBodySolver ();
};
btDefaultSoftBodySolver implements btSoftBodySolver;
interface btSoftBodyArray {
[Const] long size();
[Const] btSoftBody at(long n);
};
interface btSoftRigidDynamicsWorld {
void btSoftRigidDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver);
void addSoftBody(btSoftBody body, short collisionFilterGroup, short collisionFilterMask);
void removeSoftBody(btSoftBody body);
void removeCollisionObject(btCollisionObject collisionObject);
[Ref] btSoftBodyWorldInfo getWorldInfo();
[Ref] btSoftBodyArray getSoftBodyArray();
};
btSoftRigidDynamicsWorld implements btDiscreteDynamicsWorld;
interface btSoftBodyHelpers {
void btSoftBodyHelpers();
btSoftBody CreateRope([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 from, [Const, Ref] btVector3 to, long res, long fixeds);
btSoftBody CreatePatch([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 corner00, [Const, Ref] btVector3 corner10, [Const, Ref] btVector3 corner01, [Const, Ref] btVector3 corner11, long resx, long resy, long fixeds, boolean gendiags);
btSoftBody CreatePatchUV([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 corner00, [Const, Ref] btVector3 corner10, [Const, Ref] btVector3 corner01, [Const, Ref] btVector3 corner11, long resx, long resy, long fixeds, boolean gendiags, float[] tex_coords);
btSoftBody CreateEllipsoid([Ref] btSoftBodyWorldInfo worldInfo, [Const, Ref] btVector3 center, [Const, Ref] btVector3 radius, long res);
btSoftBody CreateFromTriMesh([Ref] btSoftBodyWorldInfo worldInfo, float[] vertices, long[] triangles, long ntriangles, boolean randomizeConstraints);
btSoftBody CreateFromConvexHull([Ref] btSoftBodyWorldInfo worldInfo, [Const] btVector3 vertices, long nvertices, boolean randomizeConstraints);
};