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