btMultiBody* btMultiBody_new(int n_links, btScalar mass, const btScalar* inertia, bool fixedBase, bool canSleep)
{
VECTOR3_CONV(inertia);
return new btMultiBody(n_links, mass, VECTOR3_USE(inertia), fixedBase, canSleep);
}
btCollisionShape* btWorldImporter_createPlaneShape(btWorldImporter* obj, const btScalar* planeNormal, btScalar planeConstant)
{
VECTOR3_CONV(planeNormal);
return obj->createPlaneShape(VECTOR3_USE(planeNormal), planeConstant);
}
btScaledBvhTriangleMeshShape* btWorldImporter_createScaledTrangleMeshShape(btWorldImporter* obj, btBvhTriangleMeshShape* meshShape, const btScalar* localScalingbtBvhTriangleMeshShape)
{
VECTOR3_CONV(localScalingbtBvhTriangleMeshShape);
return obj->createScaledTrangleMeshShape(meshShape, VECTOR3_USE(localScalingbtBvhTriangleMeshShape));
}
void btGeneric6DofSpring2Constraint_setLinearUpperLimit(btGeneric6DofSpring2Constraint* obj, const btScalar* linearUpper)
{
VECTOR3_CONV(linearUpper);
obj->setLinearUpperLimit(VECTOR3_USE(linearUpper));
}
btCollisionShape* btWorldImporter_createBoxShape(btWorldImporter* obj, const btScalar* halfExtents)
{
VECTOR3_CONV(halfExtents);
return obj->createBoxShape(VECTOR3_USE(halfExtents));
}
void btGeneric6DofSpring2Constraint_getAngularUpperLimitReversed(btGeneric6DofSpring2Constraint* obj, btScalar* angularUpper)
{
VECTOR3_CONV(angularUpper);
obj->getAngularUpperLimitReversed(VECTOR3_USE(angularUpper));
VECTOR3_DEF_OUT(angularUpper);
}
void btGeneric6DofSpring2Constraint_setAngularUpperLimitReversed(btGeneric6DofSpring2Constraint* obj, const btScalar* angularUpper)
{
VECTOR3_CONV(angularUpper);
obj->setAngularUpperLimitReversed(VECTOR3_USE(angularUpper));
}
void btMultibodyLink_setAxisTop2(btMultibodyLink* obj, int dof, const btScalar* axis)
{
VECTOR3_CONV(axis);
obj->setAxisTop(dof, VECTOR3_USE(axis));
}
void MultiBodyLink::SetAxisTop(int dof, Vector3 axis)
{
VECTOR3_CONV(axis);
_native->setAxisTop(dof, VECTOR3_USE(axis));
VECTOR3_DEL(axis);
}
/*
void btBroadphaseRayCallback_setSigns(btBroadphaseRayCallback* obj, unsigned int* value)
{
obj->m_signs = value;
}
*/
void btBroadphaseInterface_aabbTest(btBroadphaseInterface* obj, btScalar* aabbMin, btScalar* aabbMax, btBroadphaseAabbCallback* callback)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
obj->aabbTest(VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), *callback);
}
btBroadphaseProxy* btBroadphaseInterface_createProxy(btBroadphaseInterface* obj, btScalar* aabbMin, btScalar* aabbMax, int shapeType, void* userPtr, short collisionFilterGroup, short collisionFilterMask, btDispatcher* dispatcher, void* multiSapProxy)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
return obj->createProxy(VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), shapeType, userPtr, collisionFilterGroup, collisionFilterMask, dispatcher, multiSapProxy);
}
void btBroadphaseInterface_setAabb(btBroadphaseInterface* obj, btBroadphaseProxy* proxy, btScalar* aabbMin, btScalar* aabbMax, btDispatcher* dispatcher)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
obj->setAabb(proxy, VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), dispatcher);
}
void btBroadphaseInterface_rayTest3(btBroadphaseInterface* obj, btScalar* rayFrom, btScalar* rayTo, btBroadphaseRayCallback* rayCallback)
{
VECTOR3_CONV(rayFrom);
VECTOR3_CONV(rayTo);
obj->rayTest(VECTOR3_USE(rayFrom), VECTOR3_USE(rayTo), *rayCallback);
}
void btMultiBody_addLinkTorque(btMultiBody* obj, int i, const btScalar* t)
{
VECTOR3_CONV(t);
obj->addLinkTorque(i, VECTOR3_USE(t));
}
btScalar btRotationalLimitMotor_solveAngularLimits(btRotationalLimitMotor* obj, btScalar timeStep, btScalar* axis, btScalar jacDiagABInv, btRigidBody* body0, btRigidBody* body1)
{
VECTOR3_CONV(axis);
return obj->solveAngularLimits(timeStep, VECTOR3_USE(axis), jacDiagABInv, body0, body1);
}
btAxisSweep3* btAxisSweep3_new2(const btScalar* worldAabbMin, const btScalar* worldAabbMax, unsigned short maxHandles)
{
VECTOR3_CONV(worldAabbMin);
VECTOR3_CONV(worldAabbMax);
return new btAxisSweep3(VECTOR3_USE(worldAabbMin), VECTOR3_USE(worldAabbMax), maxHandles);
}
void btGeneric6DofConstraint_setAngularUpperLimit(btGeneric6DofConstraint* obj, const btScalar* angularUpper)
{
VECTOR3_CONV(angularUpper);
obj->setAngularUpperLimit(VECTOR3_USE(angularUpper));
}
btAxisSweep3* btAxisSweep3_new3(const btScalar* worldAabbMin, const btScalar* worldAabbMax, unsigned short maxHandles, btOverlappingPairCache* pairCache)
{
VECTOR3_CONV(worldAabbMin);
VECTOR3_CONV(worldAabbMax);
return new btAxisSweep3(VECTOR3_USE(worldAabbMin), VECTOR3_USE(worldAabbMax), maxHandles, pairCache);
}
void btGeneric6DofSpring2Constraint_getLinearUpperLimit(btGeneric6DofSpring2Constraint* obj, btScalar* linearUpper)
{
VECTOR3_CONV(linearUpper);
obj->getLinearUpperLimit(VECTOR3_USE(linearUpper));
VECTOR3_DEF_OUT(linearUpper);
}
btAxisSweep3* btAxisSweep3_new4(const btScalar* worldAabbMin, const btScalar* worldAabbMax, unsigned short maxHandles, btOverlappingPairCache* pairCache, bool disableRaycastAccelerator)
{
VECTOR3_CONV(worldAabbMin);
VECTOR3_CONV(worldAabbMax);
return new btAxisSweep3(VECTOR3_USE(worldAabbMin), VECTOR3_USE(worldAabbMax), maxHandles, pairCache, disableRaycastAccelerator);
}
void btGeneric6DofSpring2Constraint_setAxis(btGeneric6DofSpring2Constraint* obj, const btScalar* axis1, const btScalar* axis2)
{
VECTOR3_CONV(axis1);
VECTOR3_CONV(axis2);
obj->setAxis(VECTOR3_USE(axis1), VECTOR3_USE(axis2));
}
unsigned short btAxisSweep3_addHandle(btAxisSweep3* obj, const btScalar* aabbMin, const btScalar* aabbMax, void* pOwner, unsigned short collisionFilterGroup, unsigned short collisionFilterMask, btDispatcher* dispatcher, void* multiSapProxy)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
return obj->addHandle(VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), pOwner, collisionFilterGroup, collisionFilterMask, dispatcher, multiSapProxy);
}
btGearConstraint* btWorldImporter_createGearConstraint(btWorldImporter* obj, btRigidBody* rbA, btRigidBody* rbB, const btScalar* axisInA, const btScalar* axisInB, btScalar ratio)
{
VECTOR3_CONV(axisInA);
VECTOR3_CONV(axisInB);
return obj->createGearConstraint(*rbA, *rbB, VECTOR3_USE(axisInA), VECTOR3_USE(axisInB), ratio);
}
/*
void btAxisSweep3_processAllOverlappingPairs(btAxisSweep3* obj, btOverlapCallback* callback)
{
obj->processAllOverlappingPairs(callback);
}
*/
void btAxisSweep3_quantize(btAxisSweep3* obj, unsigned short* out, const btScalar* point, int isMax)
{
VECTOR3_CONV(point);
obj->quantize(out, VECTOR3_USE(point), isMax);
}
btMultiSphereShape* btWorldImporter_createMultiSphereShape(btWorldImporter* obj, const btScalar* positions, const btScalar* radi, int numSpheres)
{
VECTOR3_CONV(positions);
return obj->createMultiSphereShape(&VECTOR3_USE(positions), radi, numSpheres);
}
void btAxisSweep3_updateHandle(btAxisSweep3* obj, unsigned short handle, const btScalar* aabbMin, const btScalar* aabbMax, btDispatcher* dispatcher)
{
VECTOR3_CONV(aabbMin);
VECTOR3_CONV(aabbMax);
obj->updateHandle(handle, VECTOR3_USE(aabbMin), VECTOR3_USE(aabbMax), dispatcher);
}
btPoint2PointConstraint* btWorldImporter_createPoint2PointConstraint2(btWorldImporter* obj, btRigidBody* rbA, btRigidBody* rbB, const btScalar* pivotInA, const btScalar* pivotInB)
{
VECTOR3_CONV(pivotInA);
VECTOR3_CONV(pivotInB);
return obj->createPoint2PointConstraint(*rbA, *rbB, VECTOR3_USE(pivotInA), VECTOR3_USE(pivotInB));
}
bt32BitAxisSweep3* bt32BitAxisSweep3_new(const btScalar* worldAabbMin, const btScalar* worldAabbMax)
{
VECTOR3_CONV(worldAabbMin);
VECTOR3_CONV(worldAabbMax);
return new bt32BitAxisSweep3(VECTOR3_USE(worldAabbMin), VECTOR3_USE(worldAabbMax));
}
void btWorldImporter_setDynamicsWorldInfo(btWorldImporter* obj, const btScalar* gravity, const btContactSolverInfo* solverInfo)
{
VECTOR3_CONV(gravity);
obj->setDynamicsWorldInfo(VECTOR3_USE(gravity), *solverInfo);
}
void btMultiBody_worldPosToLocal(btMultiBody* obj, int i, const btScalar* vec, btScalar* value)
{
VECTOR3_CONV(vec);
VECTOR3_OUT_VAL(obj->worldPosToLocal(i, VECTOR3_USE(vec)), value);
}
