void btConvexSeparatingDistanceUtil_initSeparatingDistance(btConvexSeparatingDistanceUtil* obj, btScalar* separatingVector, btScalar separatingDistance, btScalar* transA, btScalar* transB) { VECTOR3_CONV(separatingVector); TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); obj->initSeparatingDistance(VECTOR3_USE(separatingVector), separatingDistance, TRANSFORM_USE(transA), TRANSFORM_USE(transB)); }
void btConeTwistConstraint_calcAngleInfo2(btConeTwistConstraint* obj, const btScalar* transA, const btScalar* transB, const btScalar* invInertiaWorldA, const btScalar* invInertiaWorldB) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); MATRIX3X3_CONV(invInertiaWorldA); MATRIX3X3_CONV(invInertiaWorldB); obj->calcAngleInfo2(TRANSFORM_USE(transA), TRANSFORM_USE(transB), MATRIX3X3_USE(invInertiaWorldA), MATRIX3X3_USE(invInertiaWorldB)); }
void btTransformUtil_calculateDiffAxisAngle(btScalar* transform0, btScalar* transform1, btScalar* axis, btScalar* angle) { TRANSFORM_CONV(transform0); TRANSFORM_CONV(transform1); VECTOR3_DEF(axis); btTransformUtil::calculateDiffAxisAngle(TRANSFORM_USE(transform0), TRANSFORM_USE(transform1), VECTOR3_USE(axis), *angle); VECTOR3_DEF_OUT(axis); }
void btConeTwistConstraint_getInfo2NonVirtual(btConeTwistConstraint* obj, btTypedConstraint::btConstraintInfo2* info, const btScalar* transA, const btScalar* transB, const btScalar* invInertiaWorldA, const btScalar* invInertiaWorldB) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); MATRIX3X3_CONV(invInertiaWorldA); MATRIX3X3_CONV(invInertiaWorldB); obj->getInfo2NonVirtual(info, TRANSFORM_USE(transA), TRANSFORM_USE(transB), MATRIX3X3_USE(invInertiaWorldA), MATRIX3X3_USE(invInertiaWorldB)); }
bool btConvexPenetrationDepthSolver_calcPenDepth(btConvexPenetrationDepthSolver* obj, btVoronoiSimplexSolver* simplexSolver, btConvexShape* convexA, btConvexShape* convexB, btScalar* transA, btScalar* transB, btScalar* v, btScalar* pa, btScalar* pb, btIDebugDraw* debugDraw) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); VECTOR3_CONV(v); VECTOR3_CONV(pa); VECTOR3_CONV(pb); return obj->calcPenDepth(*simplexSolver, convexA, convexB, TRANSFORM_USE(transA), TRANSFORM_USE(transB), VECTOR3_USE(v), VECTOR3_USE(pa), VECTOR3_USE(pb), debugDraw); }
void btGeneric6DofConstraint_getInfo2NonVirtual(btGeneric6DofConstraint* obj, btTypedConstraint::btConstraintInfo2* info, const btScalar* transA, const btScalar* transB, const btScalar* linVelA, const btScalar* linVelB, const btScalar* angVelA, const btScalar* angVelB) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); VECTOR3_CONV(linVelA); VECTOR3_CONV(linVelB); VECTOR3_CONV(angVelA); VECTOR3_CONV(angVelB); obj->getInfo2NonVirtual(info, TRANSFORM_USE(transA), TRANSFORM_USE(transB), VECTOR3_USE(linVelA), VECTOR3_USE(linVelB), VECTOR3_USE(angVelA), VECTOR3_USE(angVelB)); }
void btTransformUtil_calculateVelocity(btScalar* transform0, btScalar* transform1, btScalar timeStep, btScalar* linVel, btScalar* angVel) { TRANSFORM_CONV(transform0); TRANSFORM_CONV(transform1); VECTOR3_DEF(linVel); VECTOR3_DEF(angVel); btTransformUtil::calculateVelocity(TRANSFORM_USE(transform0), TRANSFORM_USE(transform1), timeStep, VECTOR3_USE(linVel), VECTOR3_USE(angVel)); VECTOR3_DEF_OUT(linVel); VECTOR3_DEF_OUT(angVel); }
int btGeneric6DofConstraint_get_limit_motor_info22(btGeneric6DofConstraint* obj, btRotationalLimitMotor* limot, const btScalar* transA, const btScalar* transB, const btScalar* linVelA, const btScalar* linVelB, const btScalar* angVelA, const btScalar* angVelB, btTypedConstraint::btConstraintInfo2* info, int row, btScalar* ax1, int rotational, int rotAllowed) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); VECTOR3_CONV(linVelA); VECTOR3_CONV(linVelB); VECTOR3_CONV(angVelA); VECTOR3_CONV(angVelB); VECTOR3_CONV(ax1); int ret = obj->get_limit_motor_info2(limot, TRANSFORM_USE(transA), TRANSFORM_USE(transB), VECTOR3_USE(linVelA), VECTOR3_USE(linVelB), VECTOR3_USE(angVelA), VECTOR3_USE(angVelB), info, row, VECTOR3_USE(ax1), rotational, rotAllowed); VECTOR3_DEF_OUT(ax1); return ret; }
bool btAABB_overlapping_trans_conservative(btAABB* obj, const btAABB* box, btScalar* trans1_to_0) { TRANSFORM_CONV(trans1_to_0); bool ret = obj->overlapping_trans_conservative(*box, TRANSFORM_USE(trans1_to_0)); TRANSFORM_DEF_OUT(trans1_to_0); return ret; }
void btPolyhedralConvexAabbCachingShape_getNonvirtualAabb(btPolyhedralConvexAabbCachingShape* obj, const btScalar* trans, btScalar* aabbMin, btScalar* aabbMax, btScalar margin) { TRANSFORM_CONV(trans); VECTOR3_DEF(aabbMin); VECTOR3_DEF(aabbMax); obj->getNonvirtualAabb(TRANSFORM_USE(trans), VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), margin); VECTOR3_DEF_OUT(aabbMin); VECTOR3_DEF_OUT(aabbMax); }
void btTransformUtil_integrateTransform(btScalar* curTrans, btScalar* linvel, btScalar* angvel, btScalar timeStep, btScalar* predictedTransform) { TRANSFORM_CONV(curTrans); VECTOR3_DEF(linvel); VECTOR3_DEF(angvel); TRANSFORM_DEF(predictedTransform); btTransformUtil::integrateTransform(TRANSFORM_USE(curTrans), VECTOR3_USE(linvel), VECTOR3_USE(angvel), timeStep, TRANSFORM_USE(predictedTransform)); TRANSFORM_DEF_OUT(predictedTransform); }
void btConvexPolyhedron_project(btConvexPolyhedron* obj, const btScalar* trans, const btScalar* dir, btScalar* minProj, btScalar* maxProj, btScalar* witnesPtMin, btScalar* witnesPtMax) { TRANSFORM_CONV(trans); VECTOR3_CONV(dir); VECTOR3_DEF(witnesPtMin); VECTOR3_DEF(witnesPtMax); obj->project(TRANSFORM_USE(trans), VECTOR3_USE(dir), *minProj, *maxProj, VECTOR3_USE(witnesPtMin), VECTOR3_USE(witnesPtMax)); VECTOR3_DEF_OUT(witnesPtMin); VECTOR3_DEF_OUT(witnesPtMax); }
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new4(btRigidBody* rbB, const btScalar* frameInB, RotateOrder rotOrder) { TRANSFORM_CONV(frameInB); return new btGeneric6DofSpring2Constraint(*rbB, TRANSFORM_USE(frameInB), rotOrder); }
void btPersistentManifold_refreshContactPoints(btPersistentManifold* obj, const btScalar* trA, const btScalar* trB) { TRANSFORM_CONV(trA); TRANSFORM_CONV(trB); obj->refreshContactPoints(TRANSFORM_USE(trA), TRANSFORM_USE(trB)); }
btGeneric6DofConstraint* btGeneric6DofConstraint_new2(btRigidBody* rbB, const btScalar* frameInB, bool useLinearReferenceFrameB) { TRANSFORM_CONV(frameInB); return new btGeneric6DofConstraint(*rbB, TRANSFORM_USE(frameInB), useLinearReferenceFrameB); }
btCollisionObject* btWorldImporter_createCollisionObject(btWorldImporter* obj, const btScalar* startTransform, btCollisionShape* shape, const char* bodyName) { TRANSFORM_CONV(startTransform); return obj->createCollisionObject(TRANSFORM_USE(startTransform), shape, bodyName); }
btConeTwistConstraint* btWorldImporter_createConeTwistConstraint2(btWorldImporter* obj, btRigidBody* rbA, const btScalar* rbAFrame) { TRANSFORM_CONV(rbAFrame); return obj->createConeTwistConstraint(*rbA, TRANSFORM_USE(rbAFrame)); }
btRigidBody* btWorldImporter_createRigidBody(btWorldImporter* obj, bool isDynamic, btScalar mass, const btScalar* startTransform, btCollisionShape* shape, const char* bodyName) { TRANSFORM_CONV(startTransform); return obj->createRigidBody(isDynamic, mass, TRANSFORM_USE(startTransform), shape, bodyName); }
btSliderConstraint* btWorldImporter_createSliderConstraint2(btWorldImporter* obj, btRigidBody* rbB, const btScalar* frameInB, bool useLinearReferenceFrameA) { TRANSFORM_CONV(frameInB); return obj->createSliderConstraint(*rbB, TRANSFORM_USE(frameInB), useLinearReferenceFrameA); }
btHingeConstraint* btWorldImporter_createHingeConstraint(btWorldImporter* obj, btRigidBody* rbA, btRigidBody* rbB, const btScalar* rbAFrame, const btScalar* rbBFrame) { TRANSFORM_CONV(rbAFrame); TRANSFORM_CONV(rbBFrame); return obj->createHingeConstraint(*rbA, *rbB, TRANSFORM_USE(rbAFrame), TRANSFORM_USE(rbBFrame)); }
btHingeConstraint* btWorldImporter_createHingeConstraint4(btWorldImporter* obj, btRigidBody* rbA, const btScalar* rbAFrame, bool useReferenceFrameA) { TRANSFORM_CONV(rbAFrame); return obj->createHingeConstraint(*rbA, TRANSFORM_USE(rbAFrame), useReferenceFrameA); }
btGeneric6DofSpring2Constraint* btWorldImporter_createGeneric6DofSpring2Constraint(btWorldImporter* obj, btRigidBody* rbA, btRigidBody* rbB, const btScalar* frameInA, const btScalar* frameInB, int rotateOrder) { TRANSFORM_CONV(frameInA); TRANSFORM_CONV(frameInB); return obj->createGeneric6DofSpring2Constraint(*rbA, *rbB, TRANSFORM_USE(frameInA), TRANSFORM_USE(frameInB), rotateOrder); }
btGeneric6DofSpringConstraint* btWorldImporter_createGeneric6DofSpringConstraint(btWorldImporter* obj, btRigidBody* rbA, btRigidBody* rbB, const btScalar* frameInA, const btScalar* frameInB, bool useLinearReferenceFrameA) { TRANSFORM_CONV(frameInA); TRANSFORM_CONV(frameInB); return obj->createGeneric6DofSpringConstraint(*rbA, *rbB, TRANSFORM_USE(frameInA), TRANSFORM_USE(frameInB), useLinearReferenceFrameA); }
void btGeneric6DofSpring2Constraint_setFrames(btGeneric6DofSpring2Constraint* obj, const btScalar* frameA, const btScalar* frameB) { TRANSFORM_CONV(frameA); TRANSFORM_CONV(frameB); obj->setFrames(TRANSFORM_USE(frameA), TRANSFORM_USE(frameB)); }
void btConeTwistConstraint_setFrames(btConeTwistConstraint* obj, const btScalar* frameA, const btScalar* frameB) { TRANSFORM_CONV(frameA); TRANSFORM_CONV(frameB); obj->setFrames(TRANSFORM_USE(frameA), TRANSFORM_USE(frameB)); }
btDefaultMotionState* btDefaultMotionState_new2(const btScalar* startTrans) { TRANSFORM_CONV(startTrans); return ALIGNED_NEW(btDefaultMotionState)(TRANSFORM_USE(startTrans)); }
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new3(btRigidBody* rbB, const btScalar* frameInB) { TRANSFORM_CONV(frameInB); return new btGeneric6DofSpring2Constraint(*rbB, TRANSFORM_USE(frameInB)); }
btConeTwistConstraint* btConeTwistConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btScalar* rbAFrame, const btScalar* rbBFrame) { TRANSFORM_CONV(rbAFrame); TRANSFORM_CONV(rbBFrame); return new btConeTwistConstraint(*rbA, *rbB, TRANSFORM_USE(rbAFrame), TRANSFORM_USE(rbBFrame)); }
btDefaultMotionState* btDefaultMotionState_new3(const btScalar* startTrans, const btScalar* centerOfMassOffset) { TRANSFORM_CONV(startTrans); TRANSFORM_CONV(centerOfMassOffset); return ALIGNED_NEW(btDefaultMotionState)(TRANSFORM_USE(startTrans), TRANSFORM_USE(centerOfMassOffset)); }
void btGeneric6DofSpring2Constraint_calculateTransforms(btGeneric6DofSpring2Constraint* obj, const btScalar* transA, const btScalar* transB) { TRANSFORM_CONV(transA); TRANSFORM_CONV(transB); obj->calculateTransforms(TRANSFORM_USE(transA), TRANSFORM_USE(transB)); }