941 lines
33 KiB
Plaintext
941 lines
33 KiB
Plaintext
|
|
// 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);
|
|
};
|