stride3d
/
BulletSharpPInvoke
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Replace split methods with optional parameters.

This commit is contained in:
AndresTraks 2016-12-29 01:26:57 +02:00
Родитель 6a862c7f6e
Коммит 7d3fcd57ff
51 изменённых файлов: 256 добавлений и 1422 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

31
BulletSharpPInvoke/Dynamics/ConeTwistConstraint.cs
Просмотреть файл

@ -98,29 +98,10 @@ namespace BulletSharp
btConeTwistConstraint_setLimit(_native, limitIndex, limitValue);
}
public void SetLimit(float swingSpan1, float swingSpan2, float twistSpan)
{
btConeTwistConstraint_setLimit2(_native, swingSpan1, swingSpan2, twistSpan);
}
public void SetLimit(float swingSpan1, float swingSpan2, float twistSpan,
float softness)
float softness = 1.0f, float biasFactor = 0.3f, float relaxationFactor = 1.0f)
{
btConeTwistConstraint_setLimit3(_native, swingSpan1, swingSpan2, twistSpan,
softness);
}
public void SetLimit(float swingSpan1, float swingSpan2, float twistSpan,
float softness, float biasFactor)
{
btConeTwistConstraint_setLimit4(_native, swingSpan1, swingSpan2, twistSpan,
softness, biasFactor);
}
public void SetLimit(float swingSpan1, float swingSpan2, float twistSpan,
float softness, float biasFactor, float relaxationFactor)
{
btConeTwistConstraint_setLimit5(_native, swingSpan1, swingSpan2, twistSpan,
btConeTwistConstraint_setLimit2(_native, swingSpan1, swingSpan2, twistSpan,
softness, biasFactor, relaxationFactor);
}
@ -363,13 +344,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setLimit(IntPtr obj, int limitIndex, float limitValue);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setLimit2(IntPtr obj, float _swingSpan1, float _swingSpan2, float _twistSpan);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setLimit3(IntPtr obj, float _swingSpan1, float _swingSpan2, float _twistSpan, float _softness);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setLimit4(IntPtr obj, float _swingSpan1, float _swingSpan2, float _twistSpan, float _softness, float _biasFactor);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setLimit5(IntPtr obj, float _swingSpan1, float _swingSpan2, float _twistSpan, float _softness, float _biasFactor, float _relaxationFactor);
static extern void btConeTwistConstraint_setLimit2(IntPtr obj, float _swingSpan1, float _swingSpan2, float _twistSpan, float _softness, float _biasFactor, float _relaxationFactor);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btConeTwistConstraint_setMaxMotorImpulse(IntPtr obj, float maxMotorImpulse);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

58
BulletSharpPInvoke/Dynamics/DynamicsWorld.cs
Просмотреть файл

@ -51,16 +51,10 @@ namespace BulletSharp
btDynamicsWorld_addAction(_native, wrapper._native);
}
public void AddConstraint(TypedConstraint constraint)
public void AddConstraint(TypedConstraint constraint, bool disableCollisionsBetweenLinkedBodies = false)
{
_constraints.Add(constraint);
btDynamicsWorld_addConstraint(_native, constraint._native);
}
public void AddConstraint(TypedConstraint constraint, bool disableCollisionsBetweenLinkedBodies)
{
_constraints.Add(constraint);
btDynamicsWorld_addConstraint2(_native, constraint._native, disableCollisionsBetweenLinkedBodies);
btDynamicsWorld_addConstraint(_native, constraint._native, disableCollisionsBetweenLinkedBodies);
if (disableCollisionsBetweenLinkedBodies)
{
@ -163,18 +157,8 @@ namespace BulletSharp
_callback(this, timeStep);
}
public void SetInternalTickCallback(InternalTickCallback cb)
{
SetInternalTickCallback(cb, WorldUserInfo, false);
}
public void SetInternalTickCallback(InternalTickCallback cb, IntPtr worldUserInfo)
{
SetInternalTickCallback(cb, worldUserInfo, false);
}
public void SetInternalTickCallback(InternalTickCallback cb, Object worldUserInfo,
bool isPreTick)
public void SetInternalTickCallback(InternalTickCallback cb, Object worldUserInfo = null,
bool isPreTick = false)
{
if (_callback != cb)
{
@ -185,32 +169,22 @@ namespace BulletSharp
{
_callbackUnmanaged = new InternalTickCallbackUnmanaged(InternalTickCallbackNative);
}
btDynamicsWorld_setInternalTickCallback3(_native,
btDynamicsWorld_setInternalTickCallback(_native,
Marshal.GetFunctionPointerForDelegate(_callbackUnmanaged), IntPtr.Zero, isPreTick);
}
else
{
_callbackUnmanaged = null;
btDynamicsWorld_setInternalTickCallback3(_native, IntPtr.Zero, IntPtr.Zero, isPreTick);
btDynamicsWorld_setInternalTickCallback(_native, IntPtr.Zero, IntPtr.Zero, isPreTick);
}
}
WorldUserInfo = worldUserInfo;
}
public int StepSimulation(float timeStep)
public int StepSimulation(float timeStep, int maxSubSteps = 1, float fixedTimeStep = 1.0f / 60.0f)
{
return btDynamicsWorld_stepSimulation(_native, timeStep);
}
public int StepSimulation(float timeStep, int maxSubSteps)
{
return btDynamicsWorld_stepSimulation2(_native, timeStep, maxSubSteps);
}
public int StepSimulation(float timeStep, int maxSubSteps, float fixedTimeStep)
{
return btDynamicsWorld_stepSimulation3(_native, timeStep, maxSubSteps,
return btDynamicsWorld_stepSimulation(_native, timeStep, maxSubSteps,
fixedTimeStep);
}
@ -287,9 +261,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_addAction(IntPtr obj, IntPtr action);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_addConstraint(IntPtr obj, IntPtr constraint);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_addConstraint2(IntPtr obj, IntPtr constraint, bool disableCollisionsBetweenLinkedBodies);
static extern void btDynamicsWorld_addConstraint(IntPtr obj, IntPtr constraint, bool disableCollisionsBetweenLinkedBodies);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_clearForces(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -313,17 +285,9 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_setGravity(IntPtr obj, [In] ref Vector3 gravity);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_setInternalTickCallback(IntPtr obj, IntPtr cb);
static extern void btDynamicsWorld_setInternalTickCallback(IntPtr obj, IntPtr cb, IntPtr worldUserInfo, bool isPreTick);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_setInternalTickCallback2(IntPtr obj, IntPtr cb, IntPtr worldUserInfo);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_setInternalTickCallback3(IntPtr obj, IntPtr cb, IntPtr worldUserInfo, bool isPreTick);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btDynamicsWorld_stepSimulation(IntPtr obj, float timeStep);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btDynamicsWorld_stepSimulation2(IntPtr obj, float timeStep, int maxSubSteps);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btDynamicsWorld_stepSimulation3(IntPtr obj, float timeStep, int maxSubSteps, float fixedTimeStep);
static extern int btDynamicsWorld_stepSimulation(IntPtr obj, float timeStep, int maxSubSteps, float fixedTimeStep);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btDynamicsWorld_synchronizeMotionStates(IntPtr obj);
}

102
BulletSharpPInvoke/Dynamics/Featherstone/MultiBody.cs
Просмотреть файл

@ -121,17 +121,9 @@ namespace BulletSharp
/*
public void ComputeAccelerationsArticulatedBodyAlgorithmMultiDof(float deltaTime,
AlignedObjectArray<float> scratchR, AlignedObjectArray<btVector3> scratchV,
AlignedObjectArray<btMatrix3x3> scratchM)
AlignedObjectArray<btMatrix3x3> scratchM, bool isConstraintPass = false)
{
btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(_native,
deltaTime, scratchR._native, scratchV._native, scratchM._native);
}
public void ComputeAccelerationsArticulatedBodyAlgorithmMultiDof(float deltaTime,
AlignedObjectArray<float> scratchR, AlignedObjectArray<btVector3> scratchV,
AlignedObjectArray<btMatrix3x3> scratchM, bool isConstraintPass)
{
btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof2(_native,
deltaTime, scratchR._native, scratchV._native, scratchM._native, isConstraintPass);
}
@ -316,23 +308,18 @@ namespace BulletSharp
}
public void SetupFixed(int linkIndex, float mass, Vector3 inertia, int parent,
Quaternion rotParentToThis, Vector3 parentComToThisPivotOffset, Vector3 thisPivotToThisComOffset)
Quaternion rotParentToThis, Vector3 parentComToThisPivotOffset, Vector3 thisPivotToThisComOffset,
bool deprecatedDisableParentCollision = true)
{
btMultiBody_setupFixed(_native, linkIndex, mass, ref inertia, parent,
ref rotParentToThis, ref parentComToThisPivotOffset, ref thisPivotToThisComOffset);
ref rotParentToThis, ref parentComToThisPivotOffset, ref thisPivotToThisComOffset,
deprecatedDisableParentCollision);
}
public void SetupPlanar(int i, float mass, Vector3 inertia, int parent, Quaternion rotParentToThis,
Vector3 rotationAxis, Vector3 parentComToThisComOffset)
Vector3 rotationAxis, Vector3 parentComToThisComOffset, bool disableParentCollision = false)
{
btMultiBody_setupPlanar(_native, i, mass, ref inertia, parent, ref rotParentToThis,
ref rotationAxis, ref parentComToThisComOffset);
}
public void SetupPlanar(int i, float mass, Vector3 inertia, int parent, Quaternion rotParentToThis,
Vector3 rotationAxis, Vector3 parentComToThisComOffset, bool disableParentCollision)
{
btMultiBody_setupPlanar2(_native, i, mass, ref inertia, parent, ref rotParentToThis,
ref rotationAxis, ref parentComToThisComOffset, disableParentCollision);
}
@ -347,65 +334,32 @@ namespace BulletSharp
public void SetupRevolute(int linkIndex, float mass, Vector3 inertia, int parentIndex,
Quaternion rotParentToThis, Vector3 jointAxis, Vector3 parentComToThisPivotOffset,
Vector3 thisPivotToThisComOffset)
Vector3 thisPivotToThisComOffset, bool disableParentCollision = false)
{
btMultiBody_setupRevolute(_native, linkIndex, mass, ref inertia, parentIndex,
ref rotParentToThis, ref jointAxis, ref parentComToThisPivotOffset,
ref thisPivotToThisComOffset);
}
public void SetupRevolute(int linkIndex, float mass, Vector3 inertia, int parentIndex,
Quaternion rotParentToThis, Vector3 jointAxis, Vector3 parentComToThisPivotOffset,
Vector3 thisPivotToThisComOffset, bool disableParentCollision)
{
btMultiBody_setupRevolute2(_native, linkIndex, mass, ref inertia, parentIndex,
ref rotParentToThis, ref jointAxis, ref parentComToThisPivotOffset,
ref thisPivotToThisComOffset, disableParentCollision);
}
public void SetupSpherical(int linkIndex, float mass, Vector3 inertia, int parent,
Quaternion rotParentToThis, Vector3 parentComToThisPivotOffset, Vector3 thisPivotToThisComOffset)
Quaternion rotParentToThis, Vector3 parentComToThisPivotOffset, Vector3 thisPivotToThisComOffset,
bool disableParentCollision = false)
{
btMultiBody_setupSpherical(_native, linkIndex, mass, ref inertia, parent,
ref rotParentToThis, ref parentComToThisPivotOffset, ref thisPivotToThisComOffset);
}
public void SetupSpherical(int linkIndex, float mass, Vector3 inertia, int parent,
Quaternion rotParentToThis, Vector3 parentComToThisPivotOffset, Vector3 thisPivotToThisComOffset,
bool disableParentCollision)
{
btMultiBody_setupSpherical2(_native, linkIndex, mass, ref inertia, parent,
ref rotParentToThis, ref parentComToThisPivotOffset, ref thisPivotToThisComOffset,
disableParentCollision);
}
public void StepPositionsMultiDof(float deltaTime)
public void StepPositionsMultiDof(float deltaTime, float[] pq = null, float[] pqd = null)
{
btMultiBody_stepPositionsMultiDof(_native, deltaTime);
}
public void StepPositionsMultiDof(float deltaTime, float[] pq)
{
btMultiBody_stepPositionsMultiDof2(_native, deltaTime, pq);
}
public void StepPositionsMultiDof(float deltaTime, float[] pq, float[] pqd)
{
btMultiBody_stepPositionsMultiDof3(_native, deltaTime, pq, pqd);
btMultiBody_stepPositionsMultiDof(_native, deltaTime, pq, pqd);
}
/*
public void StepVelocitiesMultiDof(float deltaTime, AlignedObjectArray<float> scratchR,
AlignedObjectArray<btVector3> scratchV, AlignedObjectArray<btMatrix3x3> scratchM)
AlignedObjectArray<btVector3> scratchV, AlignedObjectArray<btMatrix3x3> scratchM,
bool isConstraintPass = false)
{
btMultiBody_stepVelocitiesMultiDof(_native, deltaTime, scratchR._native,
scratchV._native, scratchM._native);
}
public void StepVelocitiesMultiDof(float deltaTime, AlignedObjectArray<float> scratchR,
AlignedObjectArray<btVector3> scratchV, AlignedObjectArray<btMatrix3x3> scratchM,
bool isConstraintPass)
{
btMultiBody_stepVelocitiesMultiDof2(_native, deltaTime, scratchR._native,
scratchV._native, scratchM._native, isConstraintPass);
}
@ -736,9 +690,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_clearVelocities(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof2(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m, bool isConstraintPass);
static extern void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m, bool isConstraintPass);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_fillConstraintJacobianMultiDof(IntPtr obj, int link, [In] ref Vector3 contact_point, [In] ref Vector3 normal_ang, [In] ref Vector3 normal_lin, float[] jac, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -907,23 +859,15 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setPosUpdated(IntPtr obj, bool updated);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupFixed(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset);
static extern void btMultiBody_setupFixed(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool deprecatedDisableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupFixed2(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool deprecatedDisableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupPlanar(IntPtr obj, int i, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 rotationAxis, [In] ref Vector3 parentComToThisComOffset);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupPlanar2(IntPtr obj, int i, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 rotationAxis, [In] ref Vector3 parentComToThisComOffset, bool disableParentCollision);
static extern void btMultiBody_setupPlanar(IntPtr obj, int i, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 rotationAxis, [In] ref Vector3 parentComToThisComOffset, bool disableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupPrismatic(IntPtr obj, int i, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 jointAxis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool disableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupRevolute(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parentIndex, [In] ref Quaternion rotParentToThis, [In] ref Vector3 jointAxis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset);
static extern void btMultiBody_setupRevolute(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parentIndex, [In] ref Quaternion rotParentToThis, [In] ref Vector3 jointAxis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool disableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupRevolute2(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parentIndex, [In] ref Quaternion rotParentToThis, [In] ref Vector3 jointAxis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool disableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupSpherical(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setupSpherical2(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool disableParentCollision);
static extern void btMultiBody_setupSpherical(IntPtr obj, int linkIndex, float mass, [In] ref Vector3 inertia, int parent, [In] ref Quaternion rotParentToThis, [In] ref Vector3 parentComToThisPivotOffset, [In] ref Vector3 thisPivotToThisComOffset, bool disableParentCollision);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setUseGyroTerm(IntPtr obj, bool useGyro);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -935,15 +879,9 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_setWorldToBaseRot(IntPtr obj, [In] ref Quaternion rot);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_stepPositionsMultiDof(IntPtr obj, float dt);
static extern void btMultiBody_stepPositionsMultiDof(IntPtr obj, float dt, float[] pq, float[] pqd);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_stepPositionsMultiDof2(IntPtr obj, float dt, float[] pq);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_stepPositionsMultiDof3(IntPtr obj, float dt, float[] pq, float[] pqd);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_stepVelocitiesMultiDof(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_stepVelocitiesMultiDof2(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m, bool isConstraintPass);
static extern void btMultiBody_stepVelocitiesMultiDof(IntPtr obj, float dt, IntPtr scratch_r, IntPtr scratch_v, IntPtr scratch_m, bool isConstraintPass);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBody_updateCollisionObjectWorldTransforms(IntPtr obj, IntPtr scratch_q, IntPtr scratch_m);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

24
BulletSharpPInvoke/Dynamics/Featherstone/MultiBodyDynamicsWorld.cs
Просмотреть файл

@ -21,22 +21,10 @@ namespace BulletSharp
_constraints = new List<MultiBodyConstraint>();
}
public void AddMultiBody(MultiBody body)
public void AddMultiBody(MultiBody body, short group = (short)CollisionFilterGroups.DefaultFilter,
short mask = (short)CollisionFilterGroups.AllFilter)
{
btMultiBodyDynamicsWorld_addMultiBody(_native, body._native);
_bodies.Add(body);
}
public void AddMultiBody(MultiBody body, CollisionFilterGroups group, CollisionFilterGroups mask)
{
btMultiBodyDynamicsWorld_addMultiBody3(_native, body._native, (short)group,
(short)mask);
_bodies.Add(body);
}
public void AddMultiBody(MultiBody body, short group, short mask)
{
btMultiBodyDynamicsWorld_addMultiBody3(_native, body._native, group,
btMultiBodyDynamicsWorld_addMultiBody(_native, body._native, group,
mask);
_bodies.Add(body);
}
@ -107,11 +95,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btMultiBodyDynamicsWorld_new(IntPtr dispatcher, IntPtr pairCache, IntPtr constraintSolver, IntPtr collisionConfiguration);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBodyDynamicsWorld_addMultiBody(IntPtr obj, IntPtr body);
//[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
//static extern void btMultiBodyDynamicsWorld_addMultiBody2(IntPtr obj, IntPtr body, short group);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBodyDynamicsWorld_addMultiBody3(IntPtr obj, IntPtr body, short group, short mask);
static extern void btMultiBodyDynamicsWorld_addMultiBody(IntPtr obj, IntPtr body, short group, short mask);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultiBodyDynamicsWorld_addMultiBodyConstraint(IntPtr obj, IntPtr constraint);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

13
BulletSharpPInvoke/Dynamics/Featherstone/MultiBodyLink.cs
Просмотреть файл

@ -65,16 +65,11 @@ namespace BulletSharp
btMultibodyLink_setAxisTop2(_native, dof, ref axis);
}
public void UpdateCacheMultiDof()
public void UpdateCacheMultiDof(float[] pq = null)
{
btMultibodyLink_updateCacheMultiDof(_native);
btMultibodyLink_updateCacheMultiDof(_native, pq);
}
/*
public void UpdateCacheMultiDof(float pq)
{
btMultibodyLink_updateCacheMultiDof2(_native, pq._native);
}
public SpatialMotionVector AbsFrameLocVelocity
{
get { return btMultibodyLink_getAbsFrameLocVelocity(_native); }
@ -443,8 +438,6 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultibodyLink_setUserPtr(IntPtr obj, IntPtr value);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultibodyLink_updateCacheMultiDof(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMultibodyLink_updateCacheMultiDof2(IntPtr obj, IntPtr pq);
static extern void btMultibodyLink_updateCacheMultiDof(IntPtr obj, float[] pq);
}
}

17
BulletSharpPInvoke/Dynamics/GearConstraint.cs
Просмотреть файл

@ -8,17 +8,8 @@ namespace BulletSharp
public class GearConstraint : TypedConstraint
{
public GearConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB, Vector3 axisInA,
Vector3 axisInB)
: base(btGearConstraint_new(rigidBodyA._native, rigidBodyB._native, ref axisInA,
ref axisInB))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public GearConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB, Vector3 axisInA,
Vector3 axisInB, float ratio)
: base(btGearConstraint_new2(rigidBodyA._native, rigidBodyB._native,
Vector3 axisInB, float ratio = 1.0f)
: base(btGearConstraint_new(rigidBodyA._native, rigidBodyB._native,
ref axisInA, ref axisInB, ratio))
{
_rigidBodyA = rigidBodyA;
@ -54,9 +45,7 @@ namespace BulletSharp
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGearConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGearConstraint_new2(IntPtr rbA, IntPtr rbB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, float ratio);
static extern IntPtr btGearConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, float ratio);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGearConstraint_getAxisA(IntPtr obj, out Vector3 axisA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

15
BulletSharpPInvoke/Dynamics/Generic6DofConstraint.cs
Просмотреть файл

@ -605,18 +605,9 @@ namespace BulletSharp
public int GetLimitMotorInfo2(RotationalLimitMotor limitMotor, Matrix transA,
Matrix transB, Vector3 linVelA, Vector3 linVelB, Vector3 angVelA, Vector3 angVelB,
ConstraintInfo2 info, int row, ref Vector3 ax1, int rotational)
ConstraintInfo2 info, int row, ref Vector3 ax1, int rotational, int rotAllowed = 0)
{
return btGeneric6DofConstraint_get_limit_motor_info2(_native, limitMotor._native,
ref transA, ref transB, ref linVelA, ref linVelB, ref angVelA, ref angVelB,
info._native, row, ref ax1, rotational);
}
public int GetLimitMotorInfo2(RotationalLimitMotor limitMotor, Matrix transA,
Matrix transB, Vector3 linVelA, Vector3 linVelB, Vector3 angVelA, Vector3 angVelB,
ConstraintInfo2 info, int row, ref Vector3 ax1, int rotational, int rotAllowed)
{
return btGeneric6DofConstraint_get_limit_motor_info22(_native, limitMotor._native,
ref transA, ref transB, ref linVelA, ref linVelB, ref angVelA, ref angVelB,
info._native, row, ref ax1, rotational, rotAllowed);
}
@ -829,9 +820,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofConstraint_calculateTransforms2(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btGeneric6DofConstraint_get_limit_motor_info2(IntPtr obj, IntPtr limot, [In] ref Matrix transA, [In] ref Matrix transB, [In] ref Vector3 linVelA, [In] ref Vector3 linVelB, [In] ref Vector3 angVelA, [In] ref Vector3 angVelB, IntPtr info, int row, [In] ref Vector3 ax1, int rotational);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btGeneric6DofConstraint_get_limit_motor_info22(IntPtr obj, IntPtr limot, [In] ref Matrix transA, [In] ref Matrix transB, [In] ref Vector3 linVelA, [In] ref Vector3 linVelB, [In] ref Vector3 angVelA, [In] ref Vector3 angVelB, IntPtr info, int row, [In] ref Vector3 ax1, int rotational, int rotAllowed);
static extern int btGeneric6DofConstraint_get_limit_motor_info2(IntPtr obj, IntPtr limot, [In] ref Matrix transA, [In] ref Matrix transB, [In] ref Vector3 linVelA, [In] ref Vector3 linVelB, [In] ref Vector3 angVelA, [In] ref Vector3 angVelB, IntPtr info, int row, [In] ref Vector3 ax1, int rotational, int rotAllowed);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btGeneric6DofConstraint_getAngle(IntPtr obj, int axis_index);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

56
BulletSharpPInvoke/Dynamics/Generic6DofSpring2Constraint.cs
Просмотреть файл

@ -667,33 +667,17 @@ namespace BulletSharp
}
public Generic6DofSpring2Constraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Matrix frameInA, Matrix frameInB)
Matrix frameInA, Matrix frameInB, RotateOrder rotOrder = RotateOrder.XYZ)
: base(btGeneric6DofSpring2Constraint_new(rigidBodyA._native, rigidBodyB._native,
ref frameInA, ref frameInB))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public Generic6DofSpring2Constraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Matrix frameInA, Matrix frameInB, RotateOrder rotOrder)
: base(btGeneric6DofSpring2Constraint_new2(rigidBodyA._native, rigidBodyB._native,
ref frameInA, ref frameInB, rotOrder))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public Generic6DofSpring2Constraint(RigidBody rigidBodyB, Matrix frameInB)
: base(btGeneric6DofSpring2Constraint_new3(rigidBodyB._native, ref frameInB))
{
_rigidBodyA = GetFixedBody();
_rigidBodyB = rigidBodyB;
}
public Generic6DofSpring2Constraint(RigidBody rigidBodyB, Matrix frameInB,
RotateOrder rotOrder)
: base(btGeneric6DofSpring2Constraint_new4(rigidBodyB._native, ref frameInB,
RotateOrder rotOrder = RotateOrder.XYZ)
: base(btGeneric6DofSpring2Constraint_new2(rigidBodyB._native, ref frameInB,
rotOrder))
{
_rigidBodyA = GetFixedBody();
@ -798,14 +782,9 @@ namespace BulletSharp
btGeneric6DofSpring2Constraint_setBounce(_native, index, bounce);
}
public void SetDamping(int index, float damping)
public void SetDamping(int index, float damping, bool limitIfNeeded = true)
{
btGeneric6DofSpring2Constraint_setDamping(_native, index, damping);
}
public void SetDamping(int index, float damping, bool limitIfNeeded)
{
btGeneric6DofSpring2Constraint_setDamping2(_native, index, damping, limitIfNeeded);
btGeneric6DofSpring2Constraint_setDamping(_native, index, damping, limitIfNeeded);
}
public void SetEquilibriumPoint()
@ -853,14 +832,9 @@ namespace BulletSharp
btGeneric6DofSpring2Constraint_setServoTarget(_native, index, target);
}
public void SetStiffness(int index, float stiffness)
public void SetStiffness(int index, float stiffness, bool limitIfNeeded = true)
{
btGeneric6DofSpring2Constraint_setStiffness(_native, index, stiffness);
}
public void SetStiffness(int index, float stiffness, bool limitIfNeeded)
{
btGeneric6DofSpring2Constraint_setStiffness2(_native, index, stiffness,
btGeneric6DofSpring2Constraint_setStiffness(_native, index, stiffness,
limitIfNeeded);
}
@ -994,13 +968,9 @@ namespace BulletSharp
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGeneric6DofSpring2Constraint_new(IntPtr rbA, IntPtr rbB, [In] ref Matrix frameInA, [In] ref Matrix frameInB);
static extern IntPtr btGeneric6DofSpring2Constraint_new(IntPtr rbA, IntPtr rbB, [In] ref Matrix frameInA, [In] ref Matrix frameInB, RotateOrder rotOrder);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGeneric6DofSpring2Constraint_new2(IntPtr rbA, IntPtr rbB, [In] ref Matrix frameInA, [In] ref Matrix frameInB, RotateOrder rotOrder);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGeneric6DofSpring2Constraint_new3(IntPtr rbB, [In] ref Matrix frameInB);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btGeneric6DofSpring2Constraint_new4(IntPtr rbB, [In] ref Matrix frameInB, RotateOrder rotOrder);
static extern IntPtr btGeneric6DofSpring2Constraint_new2(IntPtr rbB, [In] ref Matrix frameInB, RotateOrder rotOrder);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btGeneric6DofSpring2Constraint_btGetMatrixElem([In] ref Matrix mat, int index);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -1077,9 +1047,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setBounce(IntPtr obj, int index, float bounce);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setDamping(IntPtr obj, int index, float damping);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setDamping2(IntPtr obj, int index, float damping, bool limitIfNeeded);
static extern void btGeneric6DofSpring2Constraint_setDamping(IntPtr obj, int index, float damping, bool limitIfNeeded);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setEquilibriumPoint(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -1105,9 +1073,7 @@ namespace BulletSharp
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setServoTarget(IntPtr obj, int index, float target);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setStiffness(IntPtr obj, int index, float stiffness);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setStiffness2(IntPtr obj, int index, float stiffness, bool limitIfNeeded);
static extern void btGeneric6DofSpring2Constraint_setStiffness(IntPtr obj, int index, float stiffness, bool limitIfNeeded);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btGeneric6DofSpring2Constraint_setTargetVelocity(IntPtr obj, int index, float velocity);
}

88
BulletSharpPInvoke/Dynamics/HingeConstraint.cs
Просмотреть файл

@ -24,7 +24,7 @@ namespace BulletSharp
public HingeConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB, Vector3 pivotInA,
Vector3 pivotInB, Vector3 axisInA, Vector3 axisInB, bool useReferenceFrameA = false)
: base(btHingeConstraint_new2(rigidBodyA._native, rigidBodyB._native,
: base(btHingeConstraint_new(rigidBodyA._native, rigidBodyB._native,
ref pivotInA, ref pivotInB, ref axisInA, ref axisInB, useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -33,7 +33,7 @@ namespace BulletSharp
public HingeConstraint(RigidBody rigidBodyA, Vector3 pivotInA, Vector3 axisInA,
bool useReferenceFrameA = false)
: base(btHingeConstraint_new4(rigidBodyA._native, ref pivotInA, ref axisInA,
: base(btHingeConstraint_new2(rigidBodyA._native, ref pivotInA, ref axisInA,
useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -42,7 +42,7 @@ namespace BulletSharp
public HingeConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB, Matrix rigidBodyAFrame,
Matrix rigidBodyBFrame, bool useReferenceFrameA = false)
: base(btHingeConstraint_new6(rigidBodyA._native, rigidBodyB._native,
: base(btHingeConstraint_new3(rigidBodyA._native, rigidBodyB._native,
ref rigidBodyAFrame, ref rigidBodyBFrame, useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -50,7 +50,7 @@ namespace BulletSharp
}
public HingeConstraint(RigidBody rigidBodyA, Matrix rigidBodyAFrame, bool useReferenceFrameA = false)
: base(btHingeConstraint_new8(rigidBodyA._native, ref rigidBodyAFrame,
: base(btHingeConstraint_new4(rigidBodyA._native, ref rigidBodyAFrame,
useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -297,21 +297,13 @@ namespace BulletSharp
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB);
static extern IntPtr btHingeConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new2(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, bool useReferenceFrameA);
static extern IntPtr btHingeConstraint_new2(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new3(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA);
static extern IntPtr btHingeConstraint_new3(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new4(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new5(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new6(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new7(IntPtr rbA, [In] ref Matrix rbAFrame);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeConstraint_new8(IntPtr rbA, [In] ref Matrix rbAFrame, bool useReferenceFrameA);
static extern IntPtr btHingeConstraint_new4(IntPtr rbA, [In] ref Matrix rbAFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btHingeConstraint_enableAngularMotor(IntPtr obj, bool enableMotor, float targetVelocity, float maxMotorImpulse);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -406,17 +398,8 @@ namespace BulletSharp
public class HingeAccumulatedAngleConstraint : HingeConstraint
{
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Vector3 pivotInA, Vector3 pivotInB, Vector3 axisInA, Vector3 axisInB)
Vector3 pivotInA, Vector3 pivotInB, Vector3 axisInA, Vector3 axisInB, bool useReferenceFrameA = false)
: base(btHingeAccumulatedAngleConstraint_new(rigidBodyA._native, rigidBodyB._native,
ref pivotInA, ref pivotInB, ref axisInA, ref axisInB))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Vector3 pivotInA, Vector3 pivotInB, Vector3 axisInA, Vector3 axisInB, bool useReferenceFrameA)
: base(btHingeAccumulatedAngleConstraint_new2(rigidBodyA._native, rigidBodyB._native,
ref pivotInA, ref pivotInB, ref axisInA, ref axisInB, useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -424,17 +407,8 @@ namespace BulletSharp
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, Vector3 pivotInA,
Vector3 axisInA)
: base(btHingeAccumulatedAngleConstraint_new3(rigidBodyA._native, ref pivotInA,
ref axisInA))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = GetFixedBody();
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, Vector3 pivotInA,
Vector3 axisInA, bool useReferenceFrameA)
: base(btHingeAccumulatedAngleConstraint_new4(rigidBodyA._native, ref pivotInA,
Vector3 axisInA, bool useReferenceFrameA = false)
: base(btHingeAccumulatedAngleConstraint_new2(rigidBodyA._native, ref pivotInA,
ref axisInA, useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -442,33 +416,17 @@ namespace BulletSharp
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Matrix rigidBodyAFrame, Matrix rigidBodyBFrame)
: base(btHingeAccumulatedAngleConstraint_new5(rigidBodyA._native, rigidBodyB._native,
ref rigidBodyAFrame, ref rigidBodyBFrame))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, RigidBody rigidBodyB,
Matrix rigidBodyAFrame, Matrix rigidBodyBFrame, bool useReferenceFrameA)
: base(btHingeAccumulatedAngleConstraint_new6(rigidBodyA._native, rigidBodyB._native,
Matrix rigidBodyAFrame, Matrix rigidBodyBFrame, bool useReferenceFrameA = false)
: base(btHingeAccumulatedAngleConstraint_new3(rigidBodyA._native, rigidBodyB._native,
ref rigidBodyAFrame, ref rigidBodyBFrame, useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = rigidBodyB;
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, Matrix rigidBodyAFrame)
: base(btHingeAccumulatedAngleConstraint_new7(rigidBodyA._native, ref rigidBodyAFrame))
{
_rigidBodyA = rigidBodyA;
_rigidBodyB = GetFixedBody();
}
public HingeAccumulatedAngleConstraint(RigidBody rigidBodyA, Matrix rigidBodyAFrame,
bool useReferenceFrameA)
: base(btHingeAccumulatedAngleConstraint_new8(rigidBodyA._native, ref rigidBodyAFrame,
bool useReferenceFrameA = false)
: base(btHingeAccumulatedAngleConstraint_new4(rigidBodyA._native, ref rigidBodyAFrame,
useReferenceFrameA))
{
_rigidBodyA = rigidBodyA;
@ -482,21 +440,13 @@ namespace BulletSharp
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB);
static extern IntPtr btHingeAccumulatedAngleConstraint_new(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new2(IntPtr rbA, IntPtr rbB, [In] ref Vector3 pivotInA, [In] ref Vector3 pivotInB, [In] ref Vector3 axisInA, [In] ref Vector3 axisInB, bool useReferenceFrameA);
static extern IntPtr btHingeAccumulatedAngleConstraint_new2(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new3(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA);
static extern IntPtr btHingeAccumulatedAngleConstraint_new3(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new4(IntPtr rbA, [In] ref Vector3 pivotInA, [In] ref Vector3 axisInA, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new5(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new6(IntPtr rbA, IntPtr rbB, [In] ref Matrix rbAFrame, [In] ref Matrix rbBFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new7(IntPtr rbA, [In] ref Matrix rbAFrame);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btHingeAccumulatedAngleConstraint_new8(IntPtr rbA, [In] ref Matrix rbAFrame, bool useReferenceFrameA);
static extern IntPtr btHingeAccumulatedAngleConstraint_new4(IntPtr rbA, [In] ref Matrix rbAFrame, bool useReferenceFrameA);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btHingeAccumulatedAngleConstraint_getAccumulatedHingeAngle(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

15
BulletSharpPInvoke/Dynamics/MlcpSolverInterface.cs
Просмотреть файл

@ -15,17 +15,9 @@ namespace BulletSharp
/*
public bool SolveMLCP(btMatrixX<float> a, btVectorX<float> b, btVectorX<float> x,
btVectorX<float> lo, btVectorX<float> hi, AlignedObjectArray<int> limitDependency,
int numIterations)
int numIterations, bool useSparsity = true)
{
return btMLCPSolverInterface_solveMLCP(_native, a._native, b._native,
x._native, lo._native, hi._native, limitDependency._native, numIterations);
}
public bool SolveMLCP(btMatrixX<float> a, btVectorX<float> b, btVectorX<float> x,
btVectorX<float> lo, btVectorX<float> hi, AlignedObjectArray<int> limitDependency,
int numIterations, bool useSparsity)
{
return btMLCPSolverInterface_solveMLCP2(_native, a._native, b._native,
x._native, lo._native, hi._native, limitDependency._native, numIterations,
useSparsity);
}
@ -52,10 +44,7 @@ namespace BulletSharp
//[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
//[return: MarshalAs(UnmanagedType.I1)]
//static extern bool btMLCPSolverInterface_solveMLCP(IntPtr obj, IntPtr A, IntPtr b, IntPtr x, IntPtr lo, IntPtr hi, IntPtr limitDependency, int numIterations);
//[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
//[return: MarshalAs(UnmanagedType.I1)]
//static extern bool btMLCPSolverInterface_solveMLCP2(IntPtr obj, IntPtr A, IntPtr b, IntPtr x, IntPtr lo, IntPtr hi, IntPtr limitDependency, int numIterations, bool useSparsity);
//static extern bool btMLCPSolverInterface_solveMLCP(IntPtr obj, IntPtr A, IntPtr b, IntPtr x, IntPtr lo, IntPtr hi, IntPtr limitDependency, int numIterations, bool useSparsity);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btMLCPSolverInterface_delete(IntPtr obj);
}

29
BulletSharpPInvoke/Dynamics/TypedConstraint.cs
Просмотреть файл

@ -655,25 +655,10 @@ namespace BulletSharp
btAngularLimit_fit(_native, ref angle);
}
public void Set(float low, float high)
public void Set(float low, float high, float softness = 0.9f, float biasFactor = 0.3f,
float relaxationFactor = 1.0f)
{
btAngularLimit_set(_native, low, high);
}
public void Set(float low, float high, float softness)
{
btAngularLimit_set2(_native, low, high, softness);
}
public void Set(float low, float high, float softness, float biasFactor)
{
btAngularLimit_set3(_native, low, high, softness, biasFactor);
}
public void Set(float low, float high, float softness, float biasFactor,
float relaxationFactor)
{
btAngularLimit_set4(_native, low, high, softness, biasFactor, relaxationFactor);
btAngularLimit_set(_native, low, high, softness, biasFactor, relaxationFactor);
}
public void Test(float angle)
@ -780,13 +765,7 @@ namespace BulletSharp
[return: MarshalAs(UnmanagedType.I1)]
static extern bool btAngularLimit_isLimit(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btAngularLimit_set(IntPtr obj, float low, float high);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btAngularLimit_set2(IntPtr obj, float low, float high, float _softness);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btAngularLimit_set3(IntPtr obj, float low, float high, float _softness, float _biasFactor);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btAngularLimit_set4(IntPtr obj, float low, float high, float _softness, float _biasFactor, float _relaxationFactor);
static extern void btAngularLimit_set(IntPtr obj, float low, float high, float _softness, float _biasFactor, float _relaxationFactor);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btAngularLimit_test(IntPtr obj, float angle);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

20
BulletSharpPInvoke/LinearMath/PolarDecomposition.cs
Просмотреть файл

@ -14,19 +14,9 @@ namespace BulletSharp
_native = native;
}
public PolarDecomposition()
public PolarDecomposition(float tolerance = 0.0001f, int maxIterations = 16)
{
_native = btPolarDecomposition_new();
}
public PolarDecomposition(float tolerance)
{
_native = btPolarDecomposition_new2(tolerance);
}
public PolarDecomposition(float tolerance, int maxIterations)
{
_native = btPolarDecomposition_new3(tolerance, (uint)maxIterations);
_native = btPolarDecomposition_new(tolerance, (uint)maxIterations);
}
public uint Decompose(ref Matrix a, out Matrix u, out Matrix h)
@ -60,11 +50,7 @@ namespace BulletSharp
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btPolarDecomposition_new();
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btPolarDecomposition_new2(float tolerance);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btPolarDecomposition_new3(float tolerance, uint maxIterations);
static extern IntPtr btPolarDecomposition_new(float tolerance, uint maxIterations);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern uint btPolarDecomposition_decompose(IntPtr obj, [In] ref Matrix a, out Matrix u, out Matrix h);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

254
BulletSharpPInvoke/SoftBody/SoftBody.cs
Просмотреть файл

@ -2572,16 +2572,9 @@ namespace BulletSharp.SoftBody
}
public static float RayFromToTriangle(Vector3 rayFrom, Vector3 rayTo,
Vector3 rayNormalizedDirection, Vector3 a, Vector3 b, Vector3 c)
Vector3 rayNormalizedDirection, Vector3 a, Vector3 b, Vector3 c, float maxt = float.MaxValue)
{
return btSoftBody_RayFromToCaster_rayFromToTriangle(ref rayFrom,
ref rayTo, ref rayNormalizedDirection, ref a, ref b, ref c);
}
public static float RayFromToTriangle(Vector3 rayFrom, Vector3 rayTo,
Vector3 rayNormalizedDirection, Vector3 a, Vector3 b, Vector3 c, float maxt)
{
return btSoftBody_RayFromToCaster_rayFromToTriangle2(ref rayFrom,
ref rayTo, ref rayNormalizedDirection, ref a, ref b, ref c, maxt);
}
@ -2666,9 +2659,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftBody_RayFromToCaster_getTests(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btSoftBody_RayFromToCaster_rayFromToTriangle([In] ref Vector3 rayFrom, [In] ref Vector3 rayTo, [In] ref Vector3 rayNormalizedDirection, [In] ref Vector3 a, [In] ref Vector3 b, [In] ref Vector3 c);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btSoftBody_RayFromToCaster_rayFromToTriangle2([In] ref Vector3 rayFrom, [In] ref Vector3 rayTo, [In] ref Vector3 rayNormalizedDirection, [In] ref Vector3 a, [In] ref Vector3 b, [In] ref Vector3 c, float maxt);
static extern float btSoftBody_RayFromToCaster_rayFromToTriangle([In] ref Vector3 rayFrom, [In] ref Vector3 rayTo, [In] ref Vector3 rayNormalizedDirection, [In] ref Vector3 a, [In] ref Vector3 b, [In] ref Vector3 c, float maxt);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_RayFromToCaster_setFace(IntPtr obj, IntPtr value);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -3289,38 +3280,17 @@ namespace BulletSharp.SoftBody
btSoftBody_addVelocity2(_native, ref velocity, node);
}
public void AppendAnchor(int node, RigidBody body, Vector3 localPivot)
public void AppendAnchor(int node, RigidBody body, Vector3 localPivot, bool disableCollisionBetweenLinkedBodies = false,
float influence = 1.0f)
{
btSoftBody_appendAnchor(_native, node, body._native, ref localPivot);
}
public void AppendAnchor(int node, RigidBody body, Vector3 localPivot, bool disableCollisionBetweenLinkedBodies)
{
btSoftBody_appendAnchor2(_native, node, body._native, ref localPivot,
disableCollisionBetweenLinkedBodies);
}
public void AppendAnchor(int node, RigidBody body, Vector3 localPivot, bool disableCollisionBetweenLinkedBodies,
float influence)
{
btSoftBody_appendAnchor3(_native, node, body._native, ref localPivot,
btSoftBody_appendAnchor(_native, node, body._native, ref localPivot,
disableCollisionBetweenLinkedBodies, influence);
}
public void AppendAnchor(int node, RigidBody body)
public void AppendAnchor(int node, RigidBody body, bool disableCollisionBetweenLinkedBodies = false,
float influence = 1.0f)
{
btSoftBody_appendAnchor4(_native, node, body._native);
}
public void AppendAnchor(int node, RigidBody body, bool disableCollisionBetweenLinkedBodies)
{
btSoftBody_appendAnchor5(_native, node, body._native, disableCollisionBetweenLinkedBodies);
}
public void AppendAnchor(int node, RigidBody body, bool disableCollisionBetweenLinkedBodies,
float influence)
{
btSoftBody_appendAnchor6(_native, node, body._native, disableCollisionBetweenLinkedBodies,
btSoftBody_appendAnchor2(_native, node, body._native, disableCollisionBetweenLinkedBodies,
influence);
}
@ -3356,29 +3326,14 @@ namespace BulletSharp.SoftBody
btSoftBody_appendAngularJoint4(_native, specs._native, body0._native, body1._native);
}
public void AppendFace()
public void AppendFace(int model = -1, Material mat = null)
{
btSoftBody_appendFace(_native);
btSoftBody_appendFace(_native, model, mat != null ? mat._native : IntPtr.Zero);
}
public void AppendFace(int model)
public void AppendFace(int node0, int node1, int node2, Material mat = null)
{
btSoftBody_appendFace2(_native, model);
}
public void AppendFace(int model, Material mat)
{
btSoftBody_appendFace3(_native, model, mat._native);
}
public void AppendFace(int node0, int node1, int node2)
{
btSoftBody_appendFace4(_native, node0, node1, node2);
}
public void AppendFace(int node0, int node1, int node2, Material mat)
{
btSoftBody_appendFace5(_native, node0, node1, node2, mat._native);
btSoftBody_appendFace2(_native, node0, node1, node2, mat != null ? mat._native : IntPtr.Zero);
}
public void AppendLinearJoint(LinearJoint.Specs specs, SoftBody body)
@ -3401,49 +3356,19 @@ namespace BulletSharp.SoftBody
btSoftBody_appendLinearJoint4(_native, specs._native, body0._native, body1._native);
}
public void AppendLink(int node0, int node1)
public void AppendLink(int node0, int node1, Material mat = null, bool checkExist = false)
{
btSoftBody_appendLink(_native, node0, node1);
btSoftBody_appendLink(_native, node0, node1, (mat != null) ? mat._native : IntPtr.Zero, checkExist);
}
public void AppendLink(int node0, int node1, Material mat)
public void AppendLink(int model = -1, Material mat = null)
{
btSoftBody_appendLink2(_native, node0, node1, (mat != null) ? mat._native : IntPtr.Zero);
btSoftBody_appendLink2(_native, model, (mat != null) ? mat._native : IntPtr.Zero);
}
public void AppendLink(int node0, int node1, Material mat, bool checkExist)
public void AppendLink(Node node0, Node node1, Material mat = null, bool checkExist = false)
{
btSoftBody_appendLink3(_native, node0, node1, (mat != null) ? mat._native : IntPtr.Zero, checkExist);
}
public void AppendLink()
{
btSoftBody_appendLink4(_native);
}
public void AppendLink(int model)
{
btSoftBody_appendLink5(_native, model);
}
public void AppendLink(int model, Material mat)
{
btSoftBody_appendLink6(_native, model, (mat != null) ? mat._native : IntPtr.Zero);
}
public void AppendLink(Node node0, Node node1)
{
btSoftBody_appendLink7(_native, node0._native, node1._native);
}
public void AppendLink(Node node0, Node node1, Material mat)
{
btSoftBody_appendLink8(_native, node0._native, node1._native, (mat != null) ? mat._native : IntPtr.Zero);
}
public void AppendLink(Node node0, Node node1, Material mat, bool checkExist)
{
btSoftBody_appendLink9(_native, node0._native, node1._native, (mat != null) ? mat._native : IntPtr.Zero, checkExist);
btSoftBody_appendLink3(_native, node0._native, node1._native, (mat != null) ? mat._native : IntPtr.Zero, checkExist);
}
public Material AppendMaterial()
@ -3476,44 +3401,22 @@ namespace BulletSharp.SoftBody
btSoftBody_appendNote4(_native, text, ref o);
}
public void AppendNote(string text, Vector3 o, Vector4 c)
public void AppendNote(string text, Vector3 o, Vector4 c,
Node n0 = null, Node n1 = null, Node n2 = null, Node n3 = null)
{
btSoftBody_appendNote5(_native, text, ref o, ref c);
}
public void AppendNote(string text, Vector3 o, Vector4 c, Node n0)
{
btSoftBody_appendNote6(_native, text, ref o, ref c, n0._native);
}
public void AppendNote(string text, Vector3 o, Vector4 c, Node n0, Node n1)
{
btSoftBody_appendNote7(_native, text, ref o, ref c, n0._native, n1._native);
}
public void AppendNote(string text, Vector3 o, Vector4 c, Node n0, Node n1, Node n2)
{
btSoftBody_appendNote8(_native, text, ref o, ref c, n0._native, n1._native, n2._native);
}
public void AppendNote(string text, Vector3 o, Vector4 c, Node n0, Node n1, Node n2, Node n3)
{
btSoftBody_appendNote9(_native, text, ref o, ref c, n0._native, n1._native, n2._native, n3._native);
btSoftBody_appendNote5(_native, text, ref o, ref c, n0 != null ? n0._native : IntPtr.Zero,
n1 != null ? n1._native : IntPtr.Zero, n2 != null ? n2._native : IntPtr.Zero,
n3 != null ? n3._native : IntPtr.Zero);
}
public void AppendTetra(int model, Material mat)
{
btSoftBody_appendTetra(_native, model, mat._native);
btSoftBody_appendTetra(_native, model, mat != null ? mat._native : IntPtr.Zero);
}
public void AppendTetra(int node0, int node1, int node2, int node3)
public void AppendTetra(int node0, int node1, int node2, int node3, Material mat = null)
{
btSoftBody_appendTetra2(_native, node0, node1, node2, node3);
}
public void AppendTetra(int node0, int node1, int node2, int node3, Material mat)
{
btSoftBody_appendTetra3(_native, node0, node1, node2, node3, mat._native);
btSoftBody_appendTetra2(_native, node0, node1, node2, node3, mat != null ? mat._native : IntPtr.Zero);
}
public void ApplyClusters(bool drift)
@ -3647,14 +3550,9 @@ namespace BulletSharp.SoftBody
return value;
}
public int GenerateBendingConstraints(int distance)
public int GenerateBendingConstraints(int distance, Material mat = null)
{
return btSoftBody_generateBendingConstraints(_native, distance);
}
public int GenerateBendingConstraints(int distance, Material mat)
{
return btSoftBody_generateBendingConstraints2(_native, distance, mat._native);
return btSoftBody_generateBendingConstraints(_native, distance, mat != null ? mat._native : IntPtr.Zero);
}
public int GenerateClusters(int k)
@ -3687,16 +3585,11 @@ namespace BulletSharp.SoftBody
return btSoftBody_getSolver2(solver._native);
}
*/
public void IndicesToPointers()
public void IndicesToPointers(int[] map = null)
{
btSoftBody_indicesToPointers(_native);
btSoftBody_indicesToPointers(_native, map);
}
/*
public void IndicesToPointers(int map)
{
btSoftBody_indicesToPointers2(_native, map._native);
}
*/
public void InitDefaults()
{
btSoftBody_initDefaults(_native);
@ -3849,9 +3742,9 @@ namespace BulletSharp.SoftBody
btSoftBody_setTotalDensity(_native, density);
}
public void SetTotalMass(float mass, bool fromFaces)
public void SetTotalMass(float mass, bool fromFaces = false)
{
btSoftBody_setTotalMass2(_native, mass, fromFaces);
btSoftBody_setTotalMass(_native, mass, fromFaces);
}
public void SetVelocity(Vector3 velocity)
@ -3915,14 +3808,9 @@ namespace BulletSharp.SoftBody
return btSoftBody_upcast(colObj._native);
}
*/
public void UpdateArea()
public void UpdateArea(bool averageArea = true)
{
btSoftBody_updateArea(_native);
}
public void UpdateArea(bool averageArea)
{
btSoftBody_updateArea2(_native, averageArea);
btSoftBody_updateArea(_native, averageArea);
}
public void UpdateBounds()
@ -4352,7 +4240,7 @@ namespace BulletSharp.SoftBody
public float TotalMass
{
get { return btSoftBody_getTotalMass(_native); }
set { btSoftBody_setTotalMass(_native, value); }
set { SetTotalMass(value); }
}
public bool UpdateRuntimeConstants
@ -4410,17 +4298,9 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_addVelocity2(IntPtr obj, [In] ref Vector3 velocity, int node);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor(IntPtr obj, int node, IntPtr body, [In] ref Vector3 localPivot);
static extern void btSoftBody_appendAnchor(IntPtr obj, int node, IntPtr body, [In] ref Vector3 localPivot, bool disableCollisionBetweenLinkedBodies, float influence);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor2(IntPtr obj, int node, IntPtr body, [In] ref Vector3 localPivot, bool disableCollisionBetweenLinkedBodies);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor3(IntPtr obj, int node, IntPtr body, [In] ref Vector3 localPivot, bool disableCollisionBetweenLinkedBodies, float influence);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor4(IntPtr obj, int node, IntPtr body);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor5(IntPtr obj, int node, IntPtr body, bool disableCollisionBetweenLinkedBodies);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAnchor6(IntPtr obj, int node, IntPtr body, bool disableCollisionBetweenLinkedBodies, float influence);
static extern void btSoftBody_appendAnchor2(IntPtr obj, int node, IntPtr body, bool disableCollisionBetweenLinkedBodies, float influence);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAngularJoint(IntPtr obj, IntPtr specs);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4430,15 +4310,9 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendAngularJoint4(IntPtr obj, IntPtr specs, IntPtr body0, IntPtr body1);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendFace(IntPtr obj);
static extern void btSoftBody_appendFace(IntPtr obj, int model, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendFace2(IntPtr obj, int model);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendFace3(IntPtr obj, int model, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendFace4(IntPtr obj, int node0, int node1, int node2);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendFace5(IntPtr obj, int node0, int node1, int node2, IntPtr mat);
static extern void btSoftBody_appendFace2(IntPtr obj, int node0, int node1, int node2, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLinearJoint(IntPtr obj, IntPtr specs, IntPtr body);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4448,23 +4322,11 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLinearJoint4(IntPtr obj, IntPtr specs, IntPtr body0, IntPtr body1);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink(IntPtr obj, int node0, int node1);
static extern void btSoftBody_appendLink(IntPtr obj, int node0, int node1, IntPtr mat, bool bcheckexist);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink2(IntPtr obj, int node0, int node1, IntPtr mat);
static extern void btSoftBody_appendLink2(IntPtr obj, int model, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink3(IntPtr obj, int node0, int node1, IntPtr mat, bool bcheckexist);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink4(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink5(IntPtr obj, int model);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink6(IntPtr obj, int model, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink7(IntPtr obj, IntPtr node0, IntPtr node1);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink8(IntPtr obj, IntPtr node0, IntPtr node1, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendLink9(IntPtr obj, IntPtr node0, IntPtr node1, IntPtr mat, bool bcheckexist);
static extern void btSoftBody_appendLink3(IntPtr obj, IntPtr node0, IntPtr node1, IntPtr mat, bool bcheckexist);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBody_appendMaterial(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4478,21 +4340,11 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote4(IntPtr obj, string text, [In] ref Vector3 o);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote5(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote6(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c, IntPtr n0);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote7(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c, IntPtr n0, IntPtr n1);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote8(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c, IntPtr n0, IntPtr n1, IntPtr n2);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendNote9(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c, IntPtr n0, IntPtr n1, IntPtr n2, IntPtr n3);
static extern void btSoftBody_appendNote5(IntPtr obj, string text, [In] ref Vector3 o, [In] ref Vector4 c, IntPtr n0, IntPtr n1, IntPtr n2, IntPtr n3);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendTetra(IntPtr obj, int model, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendTetra2(IntPtr obj, int node0, int node1, int node2, int node3);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_appendTetra3(IntPtr obj, int node0, int node1, int node2, int node3, IntPtr mat);
static extern void btSoftBody_appendTetra2(IntPtr obj, int node0, int node1, int node2, int node3, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_applyClusters(IntPtr obj, bool drift);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4548,9 +4400,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_evaluateCom(IntPtr obj, out Vector3 value);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftBody_generateBendingConstraints(IntPtr obj, int distance);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftBody_generateBendingConstraints2(IntPtr obj, int distance, IntPtr mat);
static extern int btSoftBody_generateBendingConstraints(IntPtr obj, int distance, IntPtr mat);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftBody_generateClusters(IntPtr obj, int k);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4625,9 +4475,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBody_getWorldInfo(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_indicesToPointers(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_indicesToPointers2(IntPtr obj, IntPtr map);
static extern void btSoftBody_indicesToPointers(IntPtr obj, int[] map);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_initDefaults(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4690,9 +4538,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_setTotalDensity(IntPtr obj, float density);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_setTotalMass(IntPtr obj, float mass);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_setTotalMass2(IntPtr obj, float mass, bool fromfaces);
static extern void btSoftBody_setTotalMass(IntPtr obj, float mass, bool fromfaces);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_setVelocity(IntPtr obj, [In] ref Vector3 velocity);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -4720,9 +4566,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBody_upcast(IntPtr colObj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_updateArea(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_updateArea2(IntPtr obj, bool averageArea);
static extern void btSoftBody_updateArea(IntPtr obj, bool averageArea);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBody_updateBounds(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

106
BulletSharpPInvoke/SoftBody/SoftBodyHelpers.cs
Просмотреть файл

@ -76,7 +76,7 @@ namespace BulletSharp.SoftBody
public static SoftBody CreateFromConvexHull(SoftBodyWorldInfo worldInfo,
Vector3[] vertices, int nVertices, bool randomizeConstraints = true)
{
var body = new SoftBody(btSoftBodyHelpers_CreateFromConvexHull2(
var body = new SoftBody(btSoftBodyHelpers_CreateFromConvexHull(
worldInfo._native, vertices, nVertices, randomizeConstraints));
body.WorldInfo = worldInfo;
return body;
@ -85,7 +85,7 @@ namespace BulletSharp.SoftBody
public static SoftBody CreateFromConvexHull(SoftBodyWorldInfo worldInfo,
Vector3[] vertices, bool randomizeConstraints = true)
{
var body = new SoftBody(btSoftBodyHelpers_CreateFromConvexHull2(
var body = new SoftBody(btSoftBodyHelpers_CreateFromConvexHull(
worldInfo._native, vertices, vertices.Length, randomizeConstraints));
body.WorldInfo = worldInfo;
return body;
@ -309,19 +309,9 @@ namespace BulletSharp.SoftBody
public static SoftBody CreatePatchUV(SoftBodyWorldInfo worldInfo, Vector3 corner00,
Vector3 corner10, Vector3 corner01, Vector3 corner11, int resx, int resy,
int fixeds, bool gendiags)
int fixeds, bool gendiags, float[] texCoords = null)
{
var body = new SoftBody(btSoftBodyHelpers_CreatePatchUV(worldInfo._native,
ref corner00, ref corner10, ref corner01, ref corner11, resx, resy, fixeds, gendiags));
body.WorldInfo = worldInfo;
return body;
}
public static SoftBody CreatePatchUV(SoftBodyWorldInfo worldInfo, Vector3 corner00,
Vector3 corner10, Vector3 corner01, Vector3 corner11, int resx, int resy,
int fixeds, bool gendiags, float[] texCoords)
{
var body = new SoftBody(btSoftBodyHelpers_CreatePatchUV2(worldInfo._native,
ref corner00, ref corner10, ref corner01, ref corner11, resx, resy,
fixeds, gendiags, texCoords));
body.WorldInfo = worldInfo;
@ -357,49 +347,22 @@ namespace BulletSharp.SoftBody
return psb;
}
public static void Draw(SoftBody psb, IDebugDraw iDraw)
public static void Draw(SoftBody psb, IDebugDraw iDraw, DrawFlags drawFlags = DrawFlags.Std)
{
btSoftBodyHelpers_Draw(psb._native, DebugDraw.GetUnmanaged(iDraw));
btSoftBodyHelpers_Draw(psb._native, DebugDraw.GetUnmanaged(iDraw), drawFlags);
}
public static void Draw(SoftBody psb, IDebugDraw iDraw, int drawFlags)
public static void DrawClusterTree(SoftBody psb, IDebugDraw iDraw, int minDepth = 0,
int maxDepth = -1)
{
btSoftBodyHelpers_Draw2(psb._native, DebugDraw.GetUnmanaged(iDraw), drawFlags);
}
public static void DrawClusterTree(SoftBody psb, IDebugDraw iDraw)
{
btSoftBodyHelpers_DrawClusterTree(psb._native, DebugDraw.GetUnmanaged(iDraw));
}
public static void DrawClusterTree(SoftBody psb, IDebugDraw iDraw, int minDepth)
{
btSoftBodyHelpers_DrawClusterTree2(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth);
}
public static void DrawClusterTree(SoftBody psb, IDebugDraw iDraw, int minDepth,
int maxDepth)
{
btSoftBodyHelpers_DrawClusterTree3(psb._native, DebugDraw.GetUnmanaged(iDraw),
btSoftBodyHelpers_DrawClusterTree(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth, maxDepth);
}
public static void DrawFaceTree(SoftBody psb, IDebugDraw iDraw)
public static void DrawFaceTree(SoftBody psb, IDebugDraw iDraw, int minDepth = 0,
int maxDepth = -1)
{
btSoftBodyHelpers_DrawFaceTree(psb._native, DebugDraw.GetUnmanaged(iDraw));
}
public static void DrawFaceTree(SoftBody psb, IDebugDraw iDraw, int minDepth)
{
btSoftBodyHelpers_DrawFaceTree2(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth);
}
public static void DrawFaceTree(SoftBody psb, IDebugDraw iDraw, int minDepth,
int maxDepth)
{
btSoftBodyHelpers_DrawFaceTree3(psb._native, DebugDraw.GetUnmanaged(iDraw),
btSoftBodyHelpers_DrawFaceTree(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth, maxDepth);
}
@ -415,21 +378,10 @@ namespace BulletSharp.SoftBody
masses, areas, stress);
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw)
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw, int minDepth = 0,
int maxDepth = -1)
{
btSoftBodyHelpers_DrawNodeTree(psb._native, DebugDraw.GetUnmanaged(iDraw));
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw, int minDepth)
{
btSoftBodyHelpers_DrawNodeTree2(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth);
}
public static void DrawNodeTree(SoftBody psb, IDebugDraw iDraw, int minDepth,
int maxDepth)
{
btSoftBodyHelpers_DrawNodeTree3(psb._native, DebugDraw.GetUnmanaged(iDraw),
btSoftBodyHelpers_DrawNodeTree(psb._native, DebugDraw.GetUnmanaged(iDraw),
minDepth, maxDepth);
}
@ -525,39 +477,21 @@ namespace BulletSharp.SoftBody
}
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBodyHelpers_CreateFromConvexHull(IntPtr worldInfo, [In] Vector3[] vertices, int nvertices);
static extern IntPtr btSoftBodyHelpers_CreateFromConvexHull(IntPtr worldInfo, [In] Vector3[] vertices, int nvertices, bool randomizeConstraints);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBodyHelpers_CreateFromConvexHull2(IntPtr worldInfo, [In] Vector3[] vertices, int nvertices, bool randomizeConstraints);
static extern IntPtr btSoftBodyHelpers_CreatePatchUV(IntPtr worldInfo, [In] ref Vector3 corner00, [In] ref Vector3 corner10, [In] ref Vector3 corner01, [In] ref Vector3 corner11, int resx, int resy, int fixeds, bool gendiags, float[] tex_coords);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBodyHelpers_CreatePatchUV(IntPtr worldInfo, [In] ref Vector3 corner00, [In] ref Vector3 corner10, [In] ref Vector3 corner01, [In] ref Vector3 corner11, int resx, int resy, int fixeds, bool gendiags);
static extern void btSoftBodyHelpers_Draw(IntPtr psb, IntPtr idraw, DrawFlags drawflags);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBodyHelpers_CreatePatchUV2(IntPtr worldInfo, [In] ref Vector3 corner00, [In] ref Vector3 corner10, [In] ref Vector3 corner01, [In] ref Vector3 corner11, int resx, int resy, int fixeds, bool gendiags, float[] tex_coords);
static extern void btSoftBodyHelpers_DrawClusterTree(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_Draw(IntPtr psb, IntPtr idraw);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_Draw2(IntPtr psb, IntPtr idraw, int drawflags);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawClusterTree(IntPtr psb, IntPtr idraw);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawClusterTree2(IntPtr psb, IntPtr idraw, int minDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawClusterTree3(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawFaceTree(IntPtr psb, IntPtr idraw);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawFaceTree2(IntPtr psb, IntPtr idraw, int minDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawFaceTree3(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
static extern void btSoftBodyHelpers_DrawFaceTree(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawFrame(IntPtr psb, IntPtr idraw);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawInfos(IntPtr psb, IntPtr idraw, bool masses, bool areas, bool stress);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawNodeTree(IntPtr psb, IntPtr idraw);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawNodeTree2(IntPtr psb, IntPtr idraw, int minDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodyHelpers_DrawNodeTree3(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
static extern void btSoftBodyHelpers_DrawNodeTree(IntPtr psb, IntPtr idraw, int minDepth, int maxDepth);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftBody_Link_new2(IntPtr obj);

26
BulletSharpPInvoke/SoftBody/SoftBodySolver.cs
Просмотреть файл

@ -18,24 +18,14 @@ namespace BulletSharp.SoftBody
return btSoftBodySolver_checkInitialized(_native);
}
public void CopyBackToSoftBodies()
public void CopyBackToSoftBodies(bool bMove = true)
{
btSoftBodySolver_copyBackToSoftBodies(_native);
}
public void CopyBackToSoftBodies(bool bMove)
{
btSoftBodySolver_copyBackToSoftBodies2(_native, bMove);
btSoftBodySolver_copyBackToSoftBodies(_native, bMove);
}
/*
public void Optimize(AlignedObjectArray softBodies)
public void Optimize(AlignedObjectArray softBodies, bool forceUpdate = false)
{
btSoftBodySolver_optimize(_native, softBodies._native);
}
public void Optimize(AlignedObjectArray softBodies, bool forceUpdate)
{
btSoftBodySolver_optimize2(_native, softBodies._native, forceUpdate);
btSoftBodySolver_optimize(_native, softBodies._native, forceUpdate);
}
*/
public void PredictMotion(float solverdt)
@ -109,9 +99,7 @@ namespace BulletSharp.SoftBody
[return: MarshalAs(UnmanagedType.I1)]
static extern bool btSoftBodySolver_checkInitialized(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodySolver_copyBackToSoftBodies(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodySolver_copyBackToSoftBodies2(IntPtr obj, bool bMove);
static extern void btSoftBodySolver_copyBackToSoftBodies(IntPtr obj, bool bMove);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftBodySolver_getNumberOfPositionIterations(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
@ -121,9 +109,7 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern float btSoftBodySolver_getTimeScale(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodySolver_optimize(IntPtr obj, IntPtr softBodies);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodySolver_optimize2(IntPtr obj, IntPtr softBodies, bool forceUpdate);
static extern void btSoftBodySolver_optimize(IntPtr obj, IntPtr softBodies, bool forceUpdate);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSoftBodySolver_predictMotion(IntPtr obj, float solverdt);
//[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

27
BulletSharpPInvoke/SoftBody/SoftRigidDynamicsWorld.cs
Просмотреть файл

@ -11,28 +11,9 @@ namespace BulletSharp.SoftBody
private bool _ownsSolver;
private SoftBodyWorldInfo _worldInfo;
public SoftRigidDynamicsWorld(Dispatcher dispatcher, BroadphaseInterface pairCache,
ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration)
: base(IntPtr.Zero, dispatcher, pairCache)
{
_softBodySolver = new DefaultSoftBodySolver();
_ownsSolver = true;
_native = btSoftRigidDynamicsWorld_new2(dispatcher._native, pairCache._native,
(constraintSolver != null) ? constraintSolver._native : IntPtr.Zero,
collisionConfiguration._native, _softBodySolver._native);
_collisionObjectArray = new AlignedCollisionObjectArray(btCollisionWorld_getCollisionObjectArray(_native), this);
_constraintSolver = constraintSolver;
_worldInfo = new SoftBodyWorldInfo(btSoftRigidDynamicsWorld_getWorldInfo(_native), true);
_worldInfo.Dispatcher = dispatcher;
_worldInfo.Broadphase = pairCache;
}
public SoftRigidDynamicsWorld(Dispatcher dispatcher, BroadphaseInterface pairCache,
ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration,
SoftBodySolver softBodySolver)
SoftBodySolver softBodySolver = null)
: base(IntPtr.Zero, dispatcher, pairCache)
{
if (softBodySolver != null) {
@ -43,7 +24,7 @@ namespace BulletSharp.SoftBody
_ownsSolver = true;
}
_native = btSoftRigidDynamicsWorld_new2(dispatcher._native, pairCache._native,
_native = btSoftRigidDynamicsWorld_new(dispatcher._native, pairCache._native,
(constraintSolver != null) ? constraintSolver._native : IntPtr.Zero,
collisionConfiguration._native, _softBodySolver._native);
@ -113,10 +94,8 @@ namespace BulletSharp.SoftBody
base.Dispose(disposing);
}
//[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
//static extern IntPtr btSoftRigidDynamicsWorld_new(IntPtr dispatcher, IntPtr pairCache, IntPtr constraintSolver, IntPtr collisionConfiguration);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern IntPtr btSoftRigidDynamicsWorld_new2(IntPtr dispatcher, IntPtr pairCache, IntPtr constraintSolver, IntPtr collisionConfiguration, IntPtr softBodySolver);
static extern IntPtr btSoftRigidDynamicsWorld_new(IntPtr dispatcher, IntPtr pairCache, IntPtr constraintSolver, IntPtr collisionConfiguration, IntPtr softBodySolver);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSoftRigidDynamicsWorld_getDrawFlags(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]

25
BulletSharpPInvoke/SoftBody/SparseSdf.cs
Просмотреть файл

@ -13,31 +13,16 @@ namespace BulletSharp.SoftBody
_native = native;
}
public void GarbageCollect(int lifetime)
public void GarbageCollect(int lifetime = 256)
{
btSparseSdf3_GarbageCollect(_native, lifetime);
}
public void GarbageCollect()
{
btSparseSdf3_GarbageCollect2(_native);
}
public void Initialize(int hashSize, int clampCells)
public void Initialize(int hashSize = 2383, int clampCells = 256 * 1024)
{
btSparseSdf3_Initialize(_native, hashSize, clampCells);
}
public void Initialize(int hashSize)
{
btSparseSdf3_Initialize2(_native, hashSize);
}
public void Initialize()
{
btSparseSdf3_Initialize3(_native);
}
public int RemoveReferences(CollisionShape pcs)
{
return btSparseSdf3_RemoveReferences(_native, (pcs != null) ? pcs._native : IntPtr.Zero);
@ -53,14 +38,8 @@ namespace BulletSharp.SoftBody
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_GarbageCollect(IntPtr obj, int lifetime);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_GarbageCollect2(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_Initialize(IntPtr obj, int hashsize, int clampCells);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_Initialize2(IntPtr obj, int hashsize);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_Initialize3(IntPtr obj);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern int btSparseSdf3_RemoveReferences(IntPtr obj, IntPtr pcs);
[DllImport(Native.Dll, CallingConvention = Native.Conv), SuppressUnmanagedCodeSecurity]
static extern void btSparseSdf3_Reset(IntPtr obj);

18
libbulletc/src/btConeTwistConstraint_wrap.cpp
Просмотреть файл

@ -211,24 +211,6 @@ void btConeTwistConstraint_setLimit(btConeTwistConstraint* obj, int limitIndex,
}
void btConeTwistConstraint_setLimit2(btConeTwistConstraint* obj, btScalar _swingSpan1,
btScalar _swingSpan2, btScalar _twistSpan)
{
obj->setLimit(_swingSpan1, _swingSpan2, _twistSpan);
}
void btConeTwistConstraint_setLimit3(btConeTwistConstraint* obj, btScalar _swingSpan1,
btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness)
{
obj->setLimit(_swingSpan1, _swingSpan2, _twistSpan, _softness);
}
void btConeTwistConstraint_setLimit4(btConeTwistConstraint* obj, btScalar _swingSpan1,
btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness, btScalar _biasFactor)
{
obj->setLimit(_swingSpan1, _swingSpan2, _twistSpan, _softness, _biasFactor);
}
void btConeTwistConstraint_setLimit5(btConeTwistConstraint* obj, btScalar _swingSpan1,
btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness, btScalar _biasFactor,
btScalar _relaxationFactor)
{

5
libbulletc/src/btConeTwistConstraint_wrap.h
Просмотреть файл

@ -40,10 +40,7 @@ extern "C" {
EXPORT void btConeTwistConstraint_setFixThresh(btConeTwistConstraint* obj, btScalar fixThresh);
EXPORT void btConeTwistConstraint_setFrames(btConeTwistConstraint* obj, const btTransform* frameA, const btTransform* frameB);
EXPORT void btConeTwistConstraint_setLimit(btConeTwistConstraint* obj, int limitIndex, btScalar limitValue);
EXPORT void btConeTwistConstraint_setLimit2(btConeTwistConstraint* obj, btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan);
EXPORT void btConeTwistConstraint_setLimit3(btConeTwistConstraint* obj, btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness);
EXPORT void btConeTwistConstraint_setLimit4(btConeTwistConstraint* obj, btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness, btScalar _biasFactor);
EXPORT void btConeTwistConstraint_setLimit5(btConeTwistConstraint* obj, btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor);
EXPORT void btConeTwistConstraint_setLimit2(btConeTwistConstraint* obj, btScalar _swingSpan1, btScalar _swingSpan2, btScalar _twistSpan, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor);
EXPORT void btConeTwistConstraint_setMaxMotorImpulse(btConeTwistConstraint* obj, btScalar maxMotorImpulse);
EXPORT void btConeTwistConstraint_setMaxMotorImpulseNormalized(btConeTwistConstraint* obj, btScalar maxMotorImpulse);
EXPORT void btConeTwistConstraint_setMotorTarget(btConeTwistConstraint* obj, const btQuaternion* q);

32
libbulletc/src/btDynamicsWorld_wrap.cpp
Просмотреть файл

@ -12,12 +12,7 @@ void btDynamicsWorld_addAction(btDynamicsWorld* obj, btActionInterface* action)
obj->addAction(action);
}
void btDynamicsWorld_addConstraint(btDynamicsWorld* obj, btTypedConstraint* constraint)
{
obj->addConstraint(constraint);
}
void btDynamicsWorld_addConstraint2(btDynamicsWorld* obj, btTypedConstraint* constraint,
void btDynamicsWorld_addConstraint(btDynamicsWorld* obj, btTypedConstraint* constraint,
bool disableCollisionsBetweenLinkedBodies)
{
obj->addConstraint(constraint, disableCollisionsBetweenLinkedBodies);
@ -101,18 +96,7 @@ void btDynamicsWorld_setGravity(btDynamicsWorld* obj, const btVector3* gravity)
obj->setGravity(BTVECTOR3_USE(gravity));
}
void btDynamicsWorld_setInternalTickCallback(btDynamicsWorld* obj, btInternalTickCallback cb)
{
obj->setInternalTickCallback(cb);
}
void btDynamicsWorld_setInternalTickCallback2(btDynamicsWorld* obj, btInternalTickCallback cb,
void* worldUserInfo)
{
obj->setInternalTickCallback(cb, worldUserInfo);
}
void btDynamicsWorld_setInternalTickCallback3(btDynamicsWorld* obj, btInternalTickCallback cb,
void btDynamicsWorld_setInternalTickCallback(btDynamicsWorld* obj, btInternalTickCallback cb,
void* worldUserInfo, bool isPreTick)
{
obj->setInternalTickCallback(cb, worldUserInfo, isPreTick);
@ -123,17 +107,7 @@ void btDynamicsWorld_setWorldUserInfo(btDynamicsWorld* obj, void* worldUserInfo)
obj->setWorldUserInfo(worldUserInfo);
}
int btDynamicsWorld_stepSimulation(btDynamicsWorld* obj, btScalar timeStep)
{
return obj->stepSimulation(timeStep);
}
int btDynamicsWorld_stepSimulation2(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps)
{
return obj->stepSimulation(timeStep, maxSubSteps);
}
int btDynamicsWorld_stepSimulation3(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps,
int btDynamicsWorld_stepSimulation(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps,
btScalar fixedTimeStep)
{
return obj->stepSimulation(timeStep, maxSubSteps, fixedTimeStep);

11
libbulletc/src/btDynamicsWorld_wrap.h
Просмотреть файл

@ -4,8 +4,7 @@
extern "C" {
#endif
EXPORT void btDynamicsWorld_addAction(btDynamicsWorld* obj, btActionInterface* action);
EXPORT void btDynamicsWorld_addConstraint(btDynamicsWorld* obj, btTypedConstraint* constraint);
EXPORT void btDynamicsWorld_addConstraint2(btDynamicsWorld* obj, btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies);
EXPORT void btDynamicsWorld_addConstraint(btDynamicsWorld* obj, btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies);
EXPORT void btDynamicsWorld_addRigidBody(btDynamicsWorld* obj, btRigidBody* body);
EXPORT void btDynamicsWorld_addRigidBody2(btDynamicsWorld* obj, btRigidBody* body, short group, short mask);
EXPORT void btDynamicsWorld_clearForces(btDynamicsWorld* obj);
@ -21,13 +20,9 @@ extern "C" {
EXPORT void btDynamicsWorld_removeRigidBody(btDynamicsWorld* obj, btRigidBody* body);
EXPORT void btDynamicsWorld_setConstraintSolver(btDynamicsWorld* obj, btConstraintSolver* solver);
EXPORT void btDynamicsWorld_setGravity(btDynamicsWorld* obj, const btVector3* gravity);
EXPORT void btDynamicsWorld_setInternalTickCallback(btDynamicsWorld* obj, btInternalTickCallback cb);
EXPORT void btDynamicsWorld_setInternalTickCallback2(btDynamicsWorld* obj, btInternalTickCallback cb, void* worldUserInfo);
EXPORT void btDynamicsWorld_setInternalTickCallback3(btDynamicsWorld* obj, btInternalTickCallback cb, void* worldUserInfo, bool isPreTick);
EXPORT void btDynamicsWorld_setInternalTickCallback(btDynamicsWorld* obj, btInternalTickCallback cb, void* worldUserInfo, bool isPreTick);
EXPORT void btDynamicsWorld_setWorldUserInfo(btDynamicsWorld* obj, void* worldUserInfo);
EXPORT int btDynamicsWorld_stepSimulation(btDynamicsWorld* obj, btScalar timeStep);
EXPORT int btDynamicsWorld_stepSimulation2(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps);
EXPORT int btDynamicsWorld_stepSimulation3(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep);
EXPORT int btDynamicsWorld_stepSimulation(btDynamicsWorld* obj, btScalar timeStep, int maxSubSteps, btScalar fixedTimeStep);
EXPORT void btDynamicsWorld_synchronizeMotionStates(btDynamicsWorld* obj);
#ifdef __cplusplus
}

8
libbulletc/src/btGearConstraint_wrap.cpp
Просмотреть файл

@ -4,14 +4,6 @@
#include "btGearConstraint_wrap.h"
btGearConstraint* btGearConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* axisInA,
const btVector3* axisInB)
{
BTVECTOR3_IN(axisInA);
BTVECTOR3_IN(axisInB);
return new btGearConstraint(*rbA, *rbB, BTVECTOR3_USE(axisInA), BTVECTOR3_USE(axisInB));
}
btGearConstraint* btGearConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btVector3* axisInA,
const btVector3* axisInB, btScalar ratio)
{
BTVECTOR3_IN(axisInA);

3
libbulletc/src/btGearConstraint_wrap.h
Просмотреть файл

@ -3,8 +3,7 @@
#ifdef __cplusplus
extern "C" {
#endif
EXPORT btGearConstraint* btGearConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* axisInA, const btVector3* axisInB);
EXPORT btGearConstraint* btGearConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btVector3* axisInA, const btVector3* axisInB, btScalar ratio);
EXPORT btGearConstraint* btGearConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* axisInA, const btVector3* axisInB, btScalar ratio);
EXPORT void btGearConstraint_getAxisA(btGearConstraint* obj, btVector3* value);
EXPORT void btGearConstraint_getAxisB(btGearConstraint* obj, btVector3* value);
EXPORT btScalar btGearConstraint_getRatio(btGearConstraint* obj);

23
libbulletc/src/btGeneric6DofConstraint_wrap.cpp
Просмотреть файл

@ -430,30 +430,11 @@ void btGeneric6DofConstraint_calculateTransforms2(btGeneric6DofConstraint* obj)
obj->calculateTransforms();
}
int btGeneric6DofConstraint_get_limit_motor_info2(btGeneric6DofConstraint* obj, btRotationalLimitMotor* limot,
const btTransform* transA, const btTransform* transB, const btVector3* linVelA,
const btVector3* linVelB, const btVector3* angVelA, const btVector3* angVelB, btTypedConstraint_btConstraintInfo2* info,
int row, btVector3* ax1, int rotational)
{
BTTRANSFORM_IN(transA);
BTTRANSFORM_IN(transB);
BTVECTOR3_IN(linVelA);
BTVECTOR3_IN(linVelB);
BTVECTOR3_IN(angVelA);
BTVECTOR3_IN(angVelB);
BTVECTOR3_IN(ax1);
int ret = obj->get_limit_motor_info2(limot, BTTRANSFORM_USE(transA), BTTRANSFORM_USE(transB),
BTVECTOR3_USE(linVelA), BTVECTOR3_USE(linVelB), BTVECTOR3_USE(angVelA), BTVECTOR3_USE(angVelB),
info, row, BTVECTOR3_USE(ax1), rotational);
BTVECTOR3_DEF_OUT(ax1);
return ret;
}
int btGeneric6DofConstraint_get_limit_motor_info22(btGeneric6DofConstraint* obj,
int btGeneric6DofConstraint_get_limit_motor_info2(btGeneric6DofConstraint* obj,
btRotationalLimitMotor* limot, const btTransform* transA, const btTransform* transB,
const btVector3* linVelA, const btVector3* linVelB, const btVector3* angVelA, const btVector3* angVelB,
btTypedConstraint_btConstraintInfo2* info, int row, btVector3* ax1, int rotational,
int rotAllowed)
int rotAllowed = 0)
{
BTTRANSFORM_IN(transA);
BTTRANSFORM_IN(transB);

3
libbulletc/src/btGeneric6DofConstraint_wrap.h
Просмотреть файл

@ -84,8 +84,7 @@ extern "C" {
EXPORT void btGeneric6DofConstraint_calcAnchorPos(btGeneric6DofConstraint* obj);
EXPORT void btGeneric6DofConstraint_calculateTransforms(btGeneric6DofConstraint* obj, const btTransform* transA, const btTransform* transB);
EXPORT void btGeneric6DofConstraint_calculateTransforms2(btGeneric6DofConstraint* obj);
EXPORT int btGeneric6DofConstraint_get_limit_motor_info2(btGeneric6DofConstraint* obj, btRotationalLimitMotor* limot, const btTransform* transA, const btTransform* transB, const btVector3* linVelA, const btVector3* linVelB, const btVector3* angVelA, const btVector3* angVelB, btTypedConstraint_btConstraintInfo2* info, int row, btVector3* ax1, int rotational);
EXPORT int btGeneric6DofConstraint_get_limit_motor_info22(btGeneric6DofConstraint* obj, btRotationalLimitMotor* limot, const btTransform* transA, const btTransform* transB, const btVector3* linVelA, const btVector3* linVelB, const btVector3* angVelA, const btVector3* angVelB, btTypedConstraint_btConstraintInfo2* info, int row, btVector3* ax1, int rotational, int rotAllowed);
EXPORT int btGeneric6DofConstraint_get_limit_motor_info2(btGeneric6DofConstraint* obj, btRotationalLimitMotor* limot, const btTransform* transA, const btTransform* transB, const btVector3* linVelA, const btVector3* linVelB, const btVector3* angVelA, const btVector3* angVelB, btTypedConstraint_btConstraintInfo2* info, int row, btVector3* ax1, int rotational, int rotAllowed);
EXPORT btScalar btGeneric6DofConstraint_getAngle(btGeneric6DofConstraint* obj, int axis_index);
EXPORT void btGeneric6DofConstraint_getAngularLowerLimit(btGeneric6DofConstraint* obj, btVector3* angularLower);
EXPORT void btGeneric6DofConstraint_getAngularUpperLimit(btGeneric6DofConstraint* obj, btVector3* angularUpper);

30
libbulletc/src/btGeneric6DofSpring2Constraint_wrap.cpp
Просмотреть файл

@ -486,15 +486,6 @@ void btTranslationalLimitMotor2_delete(btTranslationalLimitMotor2* obj)
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new(btRigidBody* rbA,
btRigidBody* rbB, const btTransform* frameInA, const btTransform* frameInB)
{
BTTRANSFORM_IN(frameInA);
BTTRANSFORM_IN(frameInB);
return new btGeneric6DofSpring2Constraint(*rbA, *rbB, BTTRANSFORM_USE(frameInA),
BTTRANSFORM_USE(frameInB));
}
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new2(btRigidBody* rbA,
btRigidBody* rbB, const btTransform* frameInA, const btTransform* frameInB, RotateOrder rotOrder)
{
BTTRANSFORM_IN(frameInA);
@ -503,14 +494,7 @@ btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new2(btRigidBody*
BTTRANSFORM_USE(frameInB), rotOrder);
}
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new3(btRigidBody* rbB,
const btTransform* frameInB)
{
BTTRANSFORM_IN(frameInB);
return new btGeneric6DofSpring2Constraint(*rbB, BTTRANSFORM_USE(frameInB));
}
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new4(btRigidBody* rbB,
btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new2(btRigidBody* rbB,
const btTransform* frameInB, RotateOrder rotOrder)
{
BTTRANSFORM_IN(frameInB);
@ -766,12 +750,6 @@ void btGeneric6DofSpring2Constraint_setBounce(btGeneric6DofSpring2Constraint* ob
}
void btGeneric6DofSpring2Constraint_setDamping(btGeneric6DofSpring2Constraint* obj,
int index, btScalar damping)
{
obj->setDamping(index, damping);
}
void btGeneric6DofSpring2Constraint_setDamping2(btGeneric6DofSpring2Constraint* obj,
int index, btScalar damping, bool limitIfNeeded)
{
obj->setDamping(index, damping, limitIfNeeded);
@ -853,12 +831,6 @@ void btGeneric6DofSpring2Constraint_setServoTarget(btGeneric6DofSpring2Constrain
}
void btGeneric6DofSpring2Constraint_setStiffness(btGeneric6DofSpring2Constraint* obj,
int index, btScalar stiffness)
{
obj->setStiffness(index, stiffness);
}
void btGeneric6DofSpring2Constraint_setStiffness2(btGeneric6DofSpring2Constraint* obj,
int index, btScalar stiffness, bool limitIfNeeded)
{
obj->setStiffness(index, stiffness, limitIfNeeded);

12
libbulletc/src/btGeneric6DofSpring2Constraint_wrap.h
Просмотреть файл

@ -97,10 +97,8 @@ extern "C" {
EXPORT void btTranslationalLimitMotor2_testLimitValue(btTranslationalLimitMotor2* obj, int limitIndex, btScalar test_value);
EXPORT void btTranslationalLimitMotor2_delete(btTranslationalLimitMotor2* obj);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new(btRigidBody* rbA, btRigidBody* rbB, const btTransform* frameInA, const btTransform* frameInB);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btTransform* frameInA, const btTransform* frameInB, RotateOrder rotOrder);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new3(btRigidBody* rbB, const btTransform* frameInB);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new4(btRigidBody* rbB, const btTransform* frameInB, RotateOrder rotOrder);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new(btRigidBody* rbA, btRigidBody* rbB, const btTransform* frameInA, const btTransform* frameInB, RotateOrder rotOrder);
EXPORT btGeneric6DofSpring2Constraint* btGeneric6DofSpring2Constraint_new2(btRigidBody* rbB, const btTransform* frameInB, RotateOrder rotOrder);
EXPORT btScalar btGeneric6DofSpring2Constraint_btGetMatrixElem(const btMatrix3x3* mat, int index);
EXPORT void btGeneric6DofSpring2Constraint_calculateTransforms(btGeneric6DofSpring2Constraint* obj, const btTransform* transA, const btTransform* transB);
EXPORT void btGeneric6DofSpring2Constraint_calculateTransforms2(btGeneric6DofSpring2Constraint* obj);
@ -135,8 +133,7 @@ extern "C" {
EXPORT void btGeneric6DofSpring2Constraint_setAngularUpperLimitReversed(btGeneric6DofSpring2Constraint* obj, const btVector3* angularUpper);
EXPORT void btGeneric6DofSpring2Constraint_setAxis(btGeneric6DofSpring2Constraint* obj, const btVector3* axis1, const btVector3* axis2);
EXPORT void btGeneric6DofSpring2Constraint_setBounce(btGeneric6DofSpring2Constraint* obj, int index, btScalar bounce);
EXPORT void btGeneric6DofSpring2Constraint_setDamping(btGeneric6DofSpring2Constraint* obj, int index, btScalar damping);
EXPORT void btGeneric6DofSpring2Constraint_setDamping2(btGeneric6DofSpring2Constraint* obj, int index, btScalar damping, bool limitIfNeeded);
EXPORT void btGeneric6DofSpring2Constraint_setDamping(btGeneric6DofSpring2Constraint* obj, int index, btScalar damping, bool limitIfNeeded);
EXPORT void btGeneric6DofSpring2Constraint_setEquilibriumPoint(btGeneric6DofSpring2Constraint* obj);
EXPORT void btGeneric6DofSpring2Constraint_setEquilibriumPoint2(btGeneric6DofSpring2Constraint* obj, int index, btScalar val);
EXPORT void btGeneric6DofSpring2Constraint_setEquilibriumPoint3(btGeneric6DofSpring2Constraint* obj, int index);
@ -149,8 +146,7 @@ extern "C" {
EXPORT void btGeneric6DofSpring2Constraint_setRotationOrder(btGeneric6DofSpring2Constraint* obj, RotateOrder order);
EXPORT void btGeneric6DofSpring2Constraint_setServo(btGeneric6DofSpring2Constraint* obj, int index, bool onOff);
EXPORT void btGeneric6DofSpring2Constraint_setServoTarget(btGeneric6DofSpring2Constraint* obj, int index, btScalar target);
EXPORT void btGeneric6DofSpring2Constraint_setStiffness(btGeneric6DofSpring2Constraint* obj, int index, btScalar stiffness);
EXPORT void btGeneric6DofSpring2Constraint_setStiffness2(btGeneric6DofSpring2Constraint* obj, int index, btScalar stiffness, bool limitIfNeeded);
EXPORT void btGeneric6DofSpring2Constraint_setStiffness(btGeneric6DofSpring2Constraint* obj, int index, btScalar stiffness, bool limitIfNeeded);
EXPORT void btGeneric6DofSpring2Constraint_setTargetVelocity(btGeneric6DofSpring2Constraint* obj, int index, btScalar velocity);
#ifdef __cplusplus
}

81
libbulletc/src/btHingeConstraint_wrap.cpp
Просмотреть файл

@ -4,17 +4,6 @@
#include "btHingeConstraint_wrap.h"
btHingeConstraint* btHingeConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA,
const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB)
{
BTVECTOR3_IN(pivotInA);
BTVECTOR3_IN(pivotInB);
BTVECTOR3_IN(axisInA);
BTVECTOR3_IN(axisInB);
return new btHingeConstraint(*rbA, *rbB, BTVECTOR3_USE(pivotInA), BTVECTOR3_USE(pivotInB),
BTVECTOR3_USE(axisInA), BTVECTOR3_USE(axisInB));
}
btHingeConstraint* btHingeConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA,
const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB,
bool useReferenceFrameA)
{
@ -26,15 +15,7 @@ btHingeConstraint* btHingeConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, co
BTVECTOR3_USE(axisInA), BTVECTOR3_USE(axisInB), useReferenceFrameA);
}
btHingeConstraint* btHingeConstraint_new3(btRigidBody* rbA, const btVector3* pivotInA,
const btVector3* axisInA)
{
BTVECTOR3_IN(pivotInA);
BTVECTOR3_IN(axisInA);
return new btHingeConstraint(*rbA, BTVECTOR3_USE(pivotInA), BTVECTOR3_USE(axisInA));
}
btHingeConstraint* btHingeConstraint_new4(btRigidBody* rbA, const btVector3* pivotInA,
btHingeConstraint* btHingeConstraint_new2(btRigidBody* rbA, const btVector3* pivotInA,
const btVector3* axisInA, bool useReferenceFrameA)
{
BTVECTOR3_IN(pivotInA);
@ -43,15 +24,7 @@ btHingeConstraint* btHingeConstraint_new4(btRigidBody* rbA, const btVector3* piv
useReferenceFrameA);
}
btHingeConstraint* btHingeConstraint_new5(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame,
const btTransform* rbBFrame)
{
BTTRANSFORM_IN(rbAFrame);
BTTRANSFORM_IN(rbBFrame);
return new btHingeConstraint(*rbA, *rbB, BTTRANSFORM_USE(rbAFrame), BTTRANSFORM_USE(rbBFrame));
}
btHingeConstraint* btHingeConstraint_new6(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame,
btHingeConstraint* btHingeConstraint_new3(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame,
const btTransform* rbBFrame, bool useReferenceFrameA)
{
BTTRANSFORM_IN(rbAFrame);
@ -60,13 +33,7 @@ btHingeConstraint* btHingeConstraint_new6(btRigidBody* rbA, btRigidBody* rbB, co
useReferenceFrameA);
}
btHingeConstraint* btHingeConstraint_new7(btRigidBody* rbA, const btTransform* rbAFrame)
{
BTTRANSFORM_IN(rbAFrame);
return new btHingeConstraint(*rbA, BTTRANSFORM_USE(rbAFrame));
}
btHingeConstraint* btHingeConstraint_new8(btRigidBody* rbA, const btTransform* rbAFrame,
btHingeConstraint* btHingeConstraint_new4(btRigidBody* rbA, const btTransform* rbAFrame,
bool useReferenceFrameA)
{
BTTRANSFORM_IN(rbAFrame);
@ -323,18 +290,6 @@ void btHingeConstraint_updateRHS(btHingeConstraint* obj, btScalar timeStep)
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new(btRigidBody* rbA,
btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA,
const btVector3* axisInB)
{
BTVECTOR3_IN(pivotInA);
BTVECTOR3_IN(pivotInB);
BTVECTOR3_IN(axisInA);
BTVECTOR3_IN(axisInB);
return new btHingeAccumulatedAngleConstraint(*rbA, *rbB, BTVECTOR3_USE(pivotInA),
BTVECTOR3_USE(pivotInB), BTVECTOR3_USE(axisInA), BTVECTOR3_USE(axisInB));
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new2(btRigidBody* rbA,
btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA,
const btVector3* axisInB, bool useReferenceFrameA)
{
@ -346,15 +301,7 @@ btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new2(btRigi
BTVECTOR3_USE(pivotInB), BTVECTOR3_USE(axisInA), BTVECTOR3_USE(axisInB), useReferenceFrameA);
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new3(btRigidBody* rbA,
const btVector3* pivotInA, const btVector3* axisInA)
{
BTVECTOR3_IN(pivotInA);
BTVECTOR3_IN(axisInA);
return new btHingeAccumulatedAngleConstraint(*rbA, BTVECTOR3_USE(pivotInA), BTVECTOR3_USE(axisInA));
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new4(btRigidBody* rbA,
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new2(btRigidBody* rbA,
const btVector3* pivotInA, const btVector3* axisInA, bool useReferenceFrameA)
{
BTVECTOR3_IN(pivotInA);
@ -363,16 +310,7 @@ btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new4(btRigi
useReferenceFrameA);
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new5(btRigidBody* rbA,
btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame)
{
BTTRANSFORM_IN(rbAFrame);
BTTRANSFORM_IN(rbBFrame);
return new btHingeAccumulatedAngleConstraint(*rbA, *rbB, BTTRANSFORM_USE(rbAFrame),
BTTRANSFORM_USE(rbBFrame));
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new6(btRigidBody* rbA,
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new3(btRigidBody* rbA,
btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame, bool useReferenceFrameA)
{
BTTRANSFORM_IN(rbAFrame);
@ -381,14 +319,7 @@ btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new6(btRigi
BTTRANSFORM_USE(rbBFrame), useReferenceFrameA);
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new7(btRigidBody* rbA,
const btTransform* rbAFrame)
{
BTTRANSFORM_IN(rbAFrame);
return new btHingeAccumulatedAngleConstraint(*rbA, BTTRANSFORM_USE(rbAFrame));
}
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new8(btRigidBody* rbA,
btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new4(btRigidBody* rbA,
const btTransform* rbAFrame, bool useReferenceFrameA)
{
BTTRANSFORM_IN(rbAFrame);

24
libbulletc/src/btHingeConstraint_wrap.h
Просмотреть файл

@ -3,14 +3,10 @@
#ifdef __cplusplus
extern "C" {
#endif
EXPORT btHingeConstraint* btHingeConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB);
EXPORT btHingeConstraint* btHingeConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new3(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA);
EXPORT btHingeConstraint* btHingeConstraint_new4(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new5(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame);
EXPORT btHingeConstraint* btHingeConstraint_new6(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new7(btRigidBody* rbA, const btTransform* rbAFrame);
EXPORT btHingeConstraint* btHingeConstraint_new8(btRigidBody* rbA, const btTransform* rbAFrame, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new2(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new3(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame, bool useReferenceFrameA);
EXPORT btHingeConstraint* btHingeConstraint_new4(btRigidBody* rbA, const btTransform* rbAFrame, bool useReferenceFrameA);
EXPORT void btHingeConstraint_enableAngularMotor(btHingeConstraint* obj, bool enableMotor, btScalar targetVelocity, btScalar maxMotorImpulse);
EXPORT void btHingeConstraint_enableMotor(btHingeConstraint* obj, bool enableMotor);
EXPORT void btHingeConstraint_getAFrame(btHingeConstraint* obj, btTransform* value);
@ -54,14 +50,10 @@ extern "C" {
EXPORT void btHingeConstraint_testLimit(btHingeConstraint* obj, const btTransform* transA, const btTransform* transB);
EXPORT void btHingeConstraint_updateRHS(btHingeConstraint* obj, btScalar timeStep);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new2(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new3(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new4(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new5(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new6(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new7(btRigidBody* rbA, const btTransform* rbAFrame);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new8(btRigidBody* rbA, const btTransform* rbAFrame, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new(btRigidBody* rbA, btRigidBody* rbB, const btVector3* pivotInA, const btVector3* pivotInB, const btVector3* axisInA, const btVector3* axisInB, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new2(btRigidBody* rbA, const btVector3* pivotInA, const btVector3* axisInA, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new3(btRigidBody* rbA, btRigidBody* rbB, const btTransform* rbAFrame, const btTransform* rbBFrame, bool useReferenceFrameA);
EXPORT btHingeAccumulatedAngleConstraint* btHingeAccumulatedAngleConstraint_new4(btRigidBody* rbA, const btTransform* rbAFrame, bool useReferenceFrameA);
EXPORT btScalar btHingeAccumulatedAngleConstraint_getAccumulatedHingeAngle(btHingeAccumulatedAngleConstraint* obj);
EXPORT void btHingeAccumulatedAngleConstraint_setAccumulatedHingeAngle(btHingeAccumulatedAngleConstraint* obj, btScalar accAngle);
#ifdef __cplusplus

8
libbulletc/src/btMLCPSolverInterface_wrap.cpp
Просмотреть файл

@ -3,14 +3,6 @@
#include "btMLCPSolverInterface_wrap.h"
/*
bool btMLCPSolverInterface_solveMLCP(btMLCPSolverInterface* obj, const btMatrixX_float* A,
const btVectorX_float* b, btVectorX_float* x, const btVectorX_float* lo,
const btVectorX_float* hi, const btAlignedObjectArray_int* limitDependency,
int numIterations)
{
return obj->solveMLCP(*A, *b, *x, *lo, *hi, *limitDependency, numIterations);
}
bool btMLCPSolverInterface_solveMLCP2(btMLCPSolverInterface* obj, const btMatrixX_float* A,
const btVectorX_float* b, btVectorX_float* x, const btVectorX_float* lo,
const btVectorX_float* hi, const btAlignedObjectArray_int* limitDependency,
int numIterations, bool useSparsity)

3
libbulletc/src/btMLCPSolverInterface_wrap.h
Просмотреть файл

@ -3,8 +3,7 @@
#ifdef __cplusplus
extern "C" {
#endif
//EXPORT bool btMLCPSolverInterface_solveMLCP(btMLCPSolverInterface* obj, const btMatrixX_float* A, const btVectorX_float* b, btVectorX_float* x, const btVectorX_float* lo, const btVectorX_float* hi, const btAlignedObjectArray_int* limitDependency, int numIterations);
//EXPORT bool btMLCPSolverInterface_solveMLCP2(btMLCPSolverInterface* obj, const btMatrixX_float* A, const btVectorX_float* b, btVectorX_float* x, const btVectorX_float* lo, const btVectorX_float* hi, const btAlignedObjectArray_int* limitDependency, int numIterations, bool useSparsity);
//EXPORT bool btMLCPSolverInterface_solveMLCP(btMLCPSolverInterface* obj, const btMatrixX_float* A, const btVectorX_float* b, btVectorX_float* x, const btVectorX_float* lo, const btVectorX_float* hi, const btAlignedObjectArray_int* limitDependency, int numIterations, bool useSparsity);
EXPORT void btMLCPSolverInterface_delete(btMLCPSolverInterface* obj);
#ifdef __cplusplus
}

13
libbulletc/src/btMultiBodyDynamicsWorld_wrap.cpp
Просмотреть файл

@ -14,18 +14,7 @@ btMultiBodyDynamicsWorld* btMultiBodyDynamicsWorld_new(btDispatcher* dispatcher,
collisionConfiguration);
}
void btMultiBodyDynamicsWorld_addMultiBody(btMultiBodyDynamicsWorld* obj, btMultiBody* body)
{
obj->addMultiBody(body);
}
void btMultiBodyDynamicsWorld_addMultiBody2(btMultiBodyDynamicsWorld* obj, btMultiBody* body,
short group)
{
obj->addMultiBody(body, group);
}
void btMultiBodyDynamicsWorld_addMultiBody3(btMultiBodyDynamicsWorld* obj, btMultiBody* body,
void btMultiBodyDynamicsWorld_addMultiBody(btMultiBodyDynamicsWorld* obj, btMultiBody* body,
short group, short mask)
{
obj->addMultiBody(body, group, mask);

4
libbulletc/src/btMultiBodyDynamicsWorld_wrap.h
Просмотреть файл

@ -4,9 +4,7 @@
extern "C" {
#endif
EXPORT btMultiBodyDynamicsWorld* btMultiBodyDynamicsWorld_new(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btMultiBodyConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
EXPORT void btMultiBodyDynamicsWorld_addMultiBody(btMultiBodyDynamicsWorld* obj, btMultiBody* body);
EXPORT void btMultiBodyDynamicsWorld_addMultiBody2(btMultiBodyDynamicsWorld* obj, btMultiBody* body, short group);
EXPORT void btMultiBodyDynamicsWorld_addMultiBody3(btMultiBodyDynamicsWorld* obj, btMultiBody* body, short group, short mask);
EXPORT void btMultiBodyDynamicsWorld_addMultiBody(btMultiBodyDynamicsWorld* obj, btMultiBody* body, short group, short mask);
EXPORT void btMultiBodyDynamicsWorld_addMultiBodyConstraint(btMultiBodyDynamicsWorld* obj, btMultiBodyConstraint* constraint);
EXPORT void btMultiBodyDynamicsWorld_clearMultiBodyConstraintForces(btMultiBodyDynamicsWorld* obj);
EXPORT void btMultiBodyDynamicsWorld_clearMultiBodyForces(btMultiBodyDynamicsWorld* obj);

9
libbulletc/src/btMultiBodyLink_wrap.cpp
Просмотреть файл

@ -289,7 +289,7 @@ void btMultibodyLink_setJointName(btMultibodyLink* obj, const char* value)
obj->m_jointName = value;
}
void btMultibodyLink_setJointType(btMultibodyLink* obj, btMultibodyLink::eFeatherstoneJointType value)
void btMultibodyLink_setJointType(btMultibodyLink* obj, btMultibodyLink_eFeatherstoneJointType value)
{
obj->m_jointType = value;
}
@ -324,12 +324,7 @@ void btMultibodyLink_setUserPtr(btMultibodyLink* obj, const void* value)
obj->m_userPtr = value;
}
void btMultibodyLink_updateCacheMultiDof(btMultibodyLink* obj)
{
obj->updateCacheMultiDof();
}
void btMultibodyLink_updateCacheMultiDof2(btMultibodyLink* obj, btScalar* pq)
void btMultibodyLink_updateCacheMultiDof(btMultibodyLink* obj, btScalar* pq)
{
obj->updateCacheMultiDof(pq);
}

3
libbulletc/src/btMultiBodyLink_wrap.h
Просмотреть файл

@ -66,8 +66,7 @@ extern "C" {
EXPORT void btMultibodyLink_setPosVarCount(btMultibodyLink* obj, int value);
EXPORT void btMultibodyLink_setZeroRotParentToThis(btMultibodyLink* obj, const btQuaternion* value);
EXPORT void btMultibodyLink_setUserPtr(btMultibodyLink* obj, const void* value);
EXPORT void btMultibodyLink_updateCacheMultiDof(btMultibodyLink* obj);
EXPORT void btMultibodyLink_updateCacheMultiDof2(btMultibodyLink* obj, btScalar* pq);
EXPORT void btMultibodyLink_updateCacheMultiDof(btMultibodyLink* obj, btScalar* pq);
#ifdef __cplusplus
}
#endif

77
libbulletc/src/btMultiBody_wrap.cpp
Просмотреть файл

@ -127,14 +127,6 @@ void btMultiBody_clearVelocities(btMultiBody* obj)
}
void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(btMultiBody* obj,
btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v,
btAlignedObjectArray_btMatrix3x3* scratch_m)
{
obj->computeAccelerationsArticulatedBodyAlgorithmMultiDof(dt, *scratch_r, *scratch_v,
*scratch_m);
}
void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof2(btMultiBody* obj,
btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v,
btAlignedObjectArray_btMatrix3x3* scratch_m, bool isConstraintPass)
{
@ -570,18 +562,6 @@ void btMultiBody_setPosUpdated(btMultiBody* obj, bool updated)
}
void btMultiBody_setupFixed(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia,
int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset,
const btVector3* thisPivotToThisComOffset)
{
BTVECTOR3_IN(inertia);
BTQUATERNION_IN(rotParentToThis);
BTVECTOR3_IN(parentComToThisPivotOffset);
BTVECTOR3_IN(thisPivotToThisComOffset);
obj->setupFixed(linkIndex, mass, BTVECTOR3_USE(inertia), parent, BTQUATERNION_USE(rotParentToThis),
BTVECTOR3_USE(parentComToThisPivotOffset), BTVECTOR3_USE(thisPivotToThisComOffset));
}
void btMultiBody_setupFixed2(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia,
int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset,
const btVector3* thisPivotToThisComOffset, bool deprecatedDisableParentCollision)
{
@ -595,18 +575,6 @@ void btMultiBody_setupFixed2(btMultiBody* obj, int linkIndex, btScalar mass, con
}
void btMultiBody_setupPlanar(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia,
int parent, const btQuaternion* rotParentToThis, const btVector3* rotationAxis,
const btVector3* parentComToThisComOffset)
{
BTVECTOR3_IN(inertia);
BTQUATERNION_IN(rotParentToThis);
BTVECTOR3_IN(rotationAxis);
BTVECTOR3_IN(parentComToThisComOffset);
obj->setupPlanar(i, mass, BTVECTOR3_USE(inertia), parent, BTQUATERNION_USE(rotParentToThis),
BTVECTOR3_USE(rotationAxis), BTVECTOR3_USE(parentComToThisComOffset));
}
void btMultiBody_setupPlanar2(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia,
int parent, const btQuaternion* rotParentToThis, const btVector3* rotationAxis,
const btVector3* parentComToThisComOffset, bool disableParentCollision)
{
@ -633,19 +601,6 @@ void btMultiBody_setupPrismatic(btMultiBody* obj, int i, btScalar mass, const bt
}
void btMultiBody_setupRevolute(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia,
int parentIndex, const btQuaternion* rotParentToThis, const btVector3* jointAxis,
const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset)
{
BTVECTOR3_IN(inertia);
BTQUATERNION_IN(rotParentToThis);
BTVECTOR3_IN(jointAxis);
BTVECTOR3_IN(parentComToThisPivotOffset);
BTVECTOR3_IN(thisPivotToThisComOffset);
obj->setupRevolute(linkIndex, mass, BTVECTOR3_USE(inertia), parentIndex, BTQUATERNION_USE(rotParentToThis),
BTVECTOR3_USE(jointAxis), BTVECTOR3_USE(parentComToThisPivotOffset), BTVECTOR3_USE(thisPivotToThisComOffset));
}
void btMultiBody_setupRevolute2(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia,
int parentIndex, const btQuaternion* rotParentToThis, const btVector3* jointAxis,
const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset,
bool disableParentCollision)
@ -660,19 +615,7 @@ void btMultiBody_setupRevolute2(btMultiBody* obj, int linkIndex, btScalar mass,
disableParentCollision);
}
void btMultiBody_setupSpherical(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia,
int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset,
const btVector3* thisPivotToThisComOffset)
{
BTVECTOR3_IN(inertia);
BTQUATERNION_IN(rotParentToThis);
BTVECTOR3_IN(parentComToThisPivotOffset);
BTVECTOR3_IN(thisPivotToThisComOffset);
obj->setupSpherical(linkIndex, mass, BTVECTOR3_USE(inertia), parent, BTQUATERNION_USE(rotParentToThis),
BTVECTOR3_USE(parentComToThisPivotOffset), BTVECTOR3_USE(thisPivotToThisComOffset));
}
void btMultiBody_setupSpherical2(btMultiBody* obj, int linkIndex, btScalar mass,
void btMultiBody_setupSpherical(btMultiBody* obj, int linkIndex, btScalar mass,
const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset,
const btVector3* thisPivotToThisComOffset, bool disableParentCollision)
{
@ -711,29 +654,13 @@ void btMultiBody_setWorldToBaseRot(btMultiBody* obj, const btQuaternion* rot)
obj->setWorldToBaseRot(BTQUATERNION_USE(rot));
}
void btMultiBody_stepPositionsMultiDof(btMultiBody* obj, btScalar dt)
{
obj->stepPositionsMultiDof(dt);
}
void btMultiBody_stepPositionsMultiDof2(btMultiBody* obj, btScalar dt, btScalar* pq)
{
obj->stepPositionsMultiDof(dt, pq);
}
void btMultiBody_stepPositionsMultiDof3(btMultiBody* obj, btScalar dt, btScalar* pq,
void btMultiBody_stepPositionsMultiDof(btMultiBody* obj, btScalar dt, btScalar* pq,
btScalar* pqd)
{
obj->stepPositionsMultiDof(dt, pq, pqd);
}
void btMultiBody_stepVelocitiesMultiDof(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r,
btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m)
{
obj->stepVelocitiesMultiDof(dt, *scratch_r, *scratch_v, *scratch_m);
}
void btMultiBody_stepVelocitiesMultiDof2(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r,
btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m,
bool isConstraintPass)
{

22
libbulletc/src/btMultiBody_wrap.h
Просмотреть файл

@ -23,8 +23,7 @@ extern "C" {
EXPORT void btMultiBody_clearConstraintForces(btMultiBody* obj);
EXPORT void btMultiBody_clearForcesAndTorques(btMultiBody* obj);
EXPORT void btMultiBody_clearVelocities(btMultiBody* obj);
EXPORT void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m);
EXPORT void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof2(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m, bool isConstraintPass);
EXPORT void btMultiBody_computeAccelerationsArticulatedBodyAlgorithmMultiDof(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m, bool isConstraintPass);
EXPORT void btMultiBody_fillConstraintJacobianMultiDof(btMultiBody* obj, int link, const btVector3* contact_point, const btVector3* normal_ang, const btVector3* normal_lin, btScalar* jac, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m);
EXPORT void btMultiBody_fillContactJacobianMultiDof(btMultiBody* obj, int link, const btVector3* contact_point, const btVector3* normal, btScalar* jac, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m);
EXPORT void btMultiBody_finalizeMultiDof(btMultiBody* obj);
@ -104,25 +103,18 @@ extern "C" {
EXPORT void btMultiBody_setMaxCoordinateVelocity(btMultiBody* obj, btScalar maxVel);
EXPORT void btMultiBody_setNumLinks(btMultiBody* obj, int numLinks);
EXPORT void btMultiBody_setPosUpdated(btMultiBody* obj, bool updated);
EXPORT void btMultiBody_setupFixed(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset);
EXPORT void btMultiBody_setupFixed2(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool deprecatedDisableParentCollision);
EXPORT void btMultiBody_setupPlanar(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* rotationAxis, const btVector3* parentComToThisComOffset);
EXPORT void btMultiBody_setupPlanar2(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* rotationAxis, const btVector3* parentComToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupFixed(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool deprecatedDisableParentCollision);
EXPORT void btMultiBody_setupPlanar(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* rotationAxis, const btVector3* parentComToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupPrismatic(btMultiBody* obj, int i, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* jointAxis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupRevolute(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parentIndex, const btQuaternion* rotParentToThis, const btVector3* jointAxis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset);
EXPORT void btMultiBody_setupRevolute2(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parentIndex, const btQuaternion* rotParentToThis, const btVector3* jointAxis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupSpherical(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset);
EXPORT void btMultiBody_setupSpherical2(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupRevolute(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parentIndex, const btQuaternion* rotParentToThis, const btVector3* jointAxis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setupSpherical(btMultiBody* obj, int linkIndex, btScalar mass, const btVector3* inertia, int parent, const btQuaternion* rotParentToThis, const btVector3* parentComToThisPivotOffset, const btVector3* thisPivotToThisComOffset, bool disableParentCollision);
EXPORT void btMultiBody_setUseGyroTerm(btMultiBody* obj, bool useGyro);
EXPORT void btMultiBody_setUserIndex(btMultiBody* obj, int index);
EXPORT void btMultiBody_setUserIndex2(btMultiBody* obj, int index);
EXPORT void btMultiBody_setUserPointer(btMultiBody* obj, void* userPointer);
EXPORT void btMultiBody_setWorldToBaseRot(btMultiBody* obj, const btQuaternion* rot);
EXPORT void btMultiBody_stepPositionsMultiDof(btMultiBody* obj, btScalar dt);
EXPORT void btMultiBody_stepPositionsMultiDof2(btMultiBody* obj, btScalar dt, btScalar* pq);
EXPORT void btMultiBody_stepPositionsMultiDof3(btMultiBody* obj, btScalar dt, btScalar* pq, btScalar* pqd);
EXPORT void btMultiBody_stepVelocitiesMultiDof(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m);
EXPORT void btMultiBody_stepVelocitiesMultiDof2(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m, bool isConstraintPass);
EXPORT void btMultiBody_stepPositionsMultiDof(btMultiBody* obj, btScalar dt, btScalar* pq, btScalar* pqd);
EXPORT void btMultiBody_stepVelocitiesMultiDof(btMultiBody* obj, btScalar dt, btAlignedObjectArray_btScalar* scratch_r, btAlignedObjectArray_btVector3* scratch_v, btAlignedObjectArray_btMatrix3x3* scratch_m, bool isConstraintPass);
EXPORT void btMultiBody_updateCollisionObjectWorldTransforms(btMultiBody* obj, btAlignedObjectArray_btQuaternion* scratch_q, btAlignedObjectArray_btVector3* scratch_m);
EXPORT void btMultiBody_useGlobalVelocities(btMultiBody* obj, bool use);
EXPORT void btMultiBody_useRK4Integration(btMultiBody* obj, bool use);

12
libbulletc/src/btPolarDecomposition_wrap.cpp
Просмотреть файл

@ -3,17 +3,7 @@
#include "conversion.h"
#include "btPolarDecomposition_wrap.h"
btPolarDecomposition* btPolarDecomposition_new()
{
return new btPolarDecomposition();
}
btPolarDecomposition* btPolarDecomposition_new2(btScalar tolerance)
{
return new btPolarDecomposition(tolerance);
}
btPolarDecomposition* btPolarDecomposition_new3(btScalar tolerance, unsigned int maxIterations)
btPolarDecomposition* btPolarDecomposition_new(btScalar tolerance, unsigned int maxIterations)
{
return new btPolarDecomposition(tolerance, maxIterations);
}

4
libbulletc/src/btPolarDecomposition_wrap.h
Просмотреть файл

@ -3,9 +3,7 @@
#ifdef __cplusplus
extern "C" {
#endif
EXPORT btPolarDecomposition* btPolarDecomposition_new();
EXPORT btPolarDecomposition* btPolarDecomposition_new2(btScalar tolerance);
EXPORT btPolarDecomposition* btPolarDecomposition_new3(btScalar tolerance, unsigned int maxIterations);
EXPORT btPolarDecomposition* btPolarDecomposition_new(btScalar tolerance, unsigned int maxIterations);
EXPORT unsigned int btPolarDecomposition_decompose(btPolarDecomposition* obj, const btMatrix3x3* a, btMatrix3x3* u, btMatrix3x3* h);
EXPORT unsigned int btPolarDecomposition_maxIterations(btPolarDecomposition* obj);
EXPORT void btPolarDecomposition_delete(btPolarDecomposition* obj);

74
libbulletc/src/btSoftBodyHelpers_wrap.cpp
Просмотреть файл

@ -19,15 +19,6 @@ btSoftBody* btSoftBodyHelpers_CreateEllipsoid(btSoftBodyWorldInfo* worldInfo, co
}
#endif
btSoftBody* btSoftBodyHelpers_CreateFromConvexHull(btSoftBodyWorldInfo* worldInfo,
const btScalar* vertices, int nvertices)
{
btVector3* verticesTemp = Vector3ArrayIn(vertices, nvertices);
btSoftBody* ret = btSoftBodyHelpers::CreateFromConvexHull(*worldInfo, verticesTemp, nvertices);
delete[] verticesTemp;
return ret;
}
btSoftBody* btSoftBodyHelpers_CreateFromConvexHull2(btSoftBodyWorldInfo* worldInfo,
const btScalar* vertices, int nvertices, bool randomizeConstraints)
{
btVector3* verticesTemp = Vector3ArrayIn(vertices, nvertices);
@ -44,14 +35,7 @@ btSoftBody* btSoftBodyHelpers_CreateFromTetGenData(btSoftBodyWorldInfo* worldInf
btetralinks, bfacesfromtetras);
}
btSoftBody* btSoftBodyHelpers_CreateFromTriMesh(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices,
const int* triangles, int ntriangles)
{
return btSoftBodyHelpers::CreateFromTriMesh(*worldInfo, vertices, triangles,
ntriangles);
}
btSoftBody* btSoftBodyHelpers_CreateFromTriMesh2(btSoftBodyWorldInfo* worldInfo,
btSoftBody* btSoftBodyHelpers_CreateFromTriMesh(btSoftBodyWorldInfo* worldInfo,
const btScalar* vertices, const int* triangles, int ntriangles, bool randomizeConstraints)
{
return btSoftBodyHelpers::CreateFromTriMesh(*worldInfo, vertices, triangles,
@ -71,19 +55,6 @@ btSoftBody* btSoftBodyHelpers_CreatePatch(btSoftBodyWorldInfo* worldInfo, const
}
#endif
btSoftBody* btSoftBodyHelpers_CreatePatchUV(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00,
const btVector3* corner10, const btVector3* corner01, const btVector3* corner11,
int resx, int resy, int fixeds, bool gendiags)
{
BTVECTOR3_IN(corner00);
BTVECTOR3_IN(corner10);
BTVECTOR3_IN(corner01);
BTVECTOR3_IN(corner11);
return btSoftBodyHelpers::CreatePatchUV(*worldInfo, BTVECTOR3_USE(corner00),
BTVECTOR3_USE(corner10), BTVECTOR3_USE(corner01), BTVECTOR3_USE(corner11),
resx, resy, fixeds, gendiags);
}
btSoftBody* btSoftBodyHelpers_CreatePatchUV2(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00,
const btVector3* corner10, const btVector3* corner01, const btVector3* corner11,
int resx, int resy, int fixeds, bool gendiags, float* tex_coords)
{
@ -105,43 +76,18 @@ btSoftBody* btSoftBodyHelpers_CreateRope(btSoftBodyWorldInfo* worldInfo, const b
res, fixeds);
}
#endif
void btSoftBodyHelpers_Draw(btSoftBody* psb, btIDebugDraw* idraw)
{
btSoftBodyHelpers::Draw(psb, idraw);
}
void btSoftBodyHelpers_Draw2(btSoftBody* psb, btIDebugDraw* idraw, int drawflags)
void btSoftBodyHelpers_Draw(btSoftBody* psb, btIDebugDraw* idraw, int drawflags)
{
btSoftBodyHelpers::Draw(psb, idraw, drawflags);
}
void btSoftBodyHelpers_DrawClusterTree(btSoftBody* psb, btIDebugDraw* idraw)
{
btSoftBodyHelpers::DrawClusterTree(psb, idraw);
}
void btSoftBodyHelpers_DrawClusterTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth)
{
btSoftBodyHelpers::DrawClusterTree(psb, idraw, mindepth);
}
void btSoftBodyHelpers_DrawClusterTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
void btSoftBodyHelpers_DrawClusterTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
int maxdepth)
{
btSoftBodyHelpers::DrawClusterTree(psb, idraw, mindepth, maxdepth);
}
void btSoftBodyHelpers_DrawFaceTree(btSoftBody* psb, btIDebugDraw* idraw)
{
btSoftBodyHelpers::DrawFaceTree(psb, idraw);
}
void btSoftBodyHelpers_DrawFaceTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth)
{
btSoftBodyHelpers::DrawFaceTree(psb, idraw, mindepth);
}
void btSoftBodyHelpers_DrawFaceTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
void btSoftBodyHelpers_DrawFaceTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
int maxdepth)
{
btSoftBodyHelpers::DrawFaceTree(psb, idraw, mindepth, maxdepth);
@ -158,17 +104,7 @@ void btSoftBodyHelpers_DrawInfos(btSoftBody* psb, btIDebugDraw* idraw, bool mass
btSoftBodyHelpers::DrawInfos(psb, idraw, masses, areas, stress);
}
void btSoftBodyHelpers_DrawNodeTree(btSoftBody* psb, btIDebugDraw* idraw)
{
btSoftBodyHelpers::DrawNodeTree(psb, idraw);
}
void btSoftBodyHelpers_DrawNodeTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth)
{
btSoftBodyHelpers::DrawNodeTree(psb, idraw, mindepth);
}
void btSoftBodyHelpers_DrawNodeTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
void btSoftBodyHelpers_DrawNodeTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth,
int maxdepth)
{
btSoftBodyHelpers::DrawNodeTree(psb, idraw, mindepth, maxdepth);

24
libbulletc/src/btSoftBodyHelpers_wrap.h
Просмотреть файл

@ -7,32 +7,22 @@ extern "C" {
EXPORT float btSoftBodyHelpers_CalculateUV(int resx, int resy, int ix, int iy, int id);
EXPORT btSoftBody* btSoftBodyHelpers_CreateEllipsoid(btSoftBodyWorldInfo* worldInfo, const btVector3* center, const btVector3* radius, int res);
#endif
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromConvexHull(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, int nvertices);
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromConvexHull2(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, int nvertices, bool randomizeConstraints);
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromConvexHull(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, int nvertices, bool randomizeConstraints);
#ifndef BULLETC_DISABLE_SOFTBODY_HELPERS
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromTetGenData(btSoftBodyWorldInfo* worldInfo, const char* ele, const char* face, const char* node, bool bfacelinks, bool btetralinks, bool bfacesfromtetras);
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromTriMesh(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, const int* triangles, int ntriangles);
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromTriMesh2(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, const int* triangles, int ntriangles, bool randomizeConstraints);
EXPORT btSoftBody* btSoftBodyHelpers_CreateFromTriMesh(btSoftBodyWorldInfo* worldInfo, const btScalar* vertices, const int* triangles, int ntriangles, bool randomizeConstraints);
EXPORT btSoftBody* btSoftBodyHelpers_CreatePatch(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00, const btVector3* corner10, const btVector3* corner01, const btVector3* corner11, int resx, int resy, int fixeds, bool gendiags);
#endif
EXPORT btSoftBody* btSoftBodyHelpers_CreatePatchUV(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00, const btVector3* corner10, const btVector3* corner01, const btVector3* corner11, int resx, int resy, int fixeds, bool gendiags);
EXPORT btSoftBody* btSoftBodyHelpers_CreatePatchUV2(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00, const btVector3* corner10, const btVector3* corner01, const btVector3* corner11, int resx, int resy, int fixeds, bool gendiags, float* tex_coords);
EXPORT btSoftBody* btSoftBodyHelpers_CreatePatchUV(btSoftBodyWorldInfo* worldInfo, const btVector3* corner00, const btVector3* corner10, const btVector3* corner01, const btVector3* corner11, int resx, int resy, int fixeds, bool gendiags, float* tex_coords);
#ifndef BULLETC_DISABLE_SOFTBODY_HELPERS
EXPORT btSoftBody* btSoftBodyHelpers_CreateRope(btSoftBodyWorldInfo* worldInfo, const btVector3* from, const btVector3* to, int res, int fixeds);
#endif
EXPORT void btSoftBodyHelpers_Draw(btSoftBody* psb, btIDebugDraw* idraw);
EXPORT void btSoftBodyHelpers_Draw2(btSoftBody* psb, btIDebugDraw* idraw, int drawflags);
EXPORT void btSoftBodyHelpers_DrawClusterTree(btSoftBody* psb, btIDebugDraw* idraw);
EXPORT void btSoftBodyHelpers_DrawClusterTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth);
EXPORT void btSoftBodyHelpers_DrawClusterTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
EXPORT void btSoftBodyHelpers_DrawFaceTree(btSoftBody* psb, btIDebugDraw* idraw);
EXPORT void btSoftBodyHelpers_DrawFaceTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth);
EXPORT void btSoftBodyHelpers_DrawFaceTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
EXPORT void btSoftBodyHelpers_Draw(btSoftBody* psb, btIDebugDraw* idraw, int drawflags);
EXPORT void btSoftBodyHelpers_DrawClusterTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
EXPORT void btSoftBodyHelpers_DrawFaceTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
EXPORT void btSoftBodyHelpers_DrawFrame(btSoftBody* psb, btIDebugDraw* idraw);
EXPORT void btSoftBodyHelpers_DrawInfos(btSoftBody* psb, btIDebugDraw* idraw, bool masses, bool areas, bool stress);
EXPORT void btSoftBodyHelpers_DrawNodeTree(btSoftBody* psb, btIDebugDraw* idraw);
EXPORT void btSoftBodyHelpers_DrawNodeTree2(btSoftBody* psb, btIDebugDraw* idraw, int mindepth);
EXPORT void btSoftBodyHelpers_DrawNodeTree3(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
EXPORT void btSoftBodyHelpers_DrawNodeTree(btSoftBody* psb, btIDebugDraw* idraw, int mindepth, int maxdepth);
#ifndef BULLETC_DISABLE_SOFTBODY_HELPERS
EXPORT void btSoftBodyHelpers_ReoptimizeLinkOrder(btSoftBody* psb);
#endif

14
libbulletc/src/btSoftBodySolvers_wrap.cpp
Просмотреть файл

@ -7,12 +7,7 @@ bool btSoftBodySolver_checkInitialized(btSoftBodySolver* obj)
return obj->checkInitialized();
}
void btSoftBodySolver_copyBackToSoftBodies(btSoftBodySolver* obj)
{
obj->copyBackToSoftBodies();
}
void btSoftBodySolver_copyBackToSoftBodies2(btSoftBodySolver* obj, bool bMove)
void btSoftBodySolver_copyBackToSoftBodies(btSoftBodySolver* obj, bool bMove)
{
obj->copyBackToSoftBodies(bMove);
}
@ -37,12 +32,7 @@ float btSoftBodySolver_getTimeScale(btSoftBodySolver* obj)
return obj->getTimeScale();
}
/*
void btSoftBodySolver_optimize(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies)
{
obj->optimize(*softBodies);
}
void btSoftBodySolver_optimize2(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies,
void btSoftBodySolver_optimize(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies,
bool forceUpdate)
{
obj->optimize(*softBodies, forceUpdate);

6
libbulletc/src/btSoftBodySolvers_wrap.h
Просмотреть файл

@ -4,14 +4,12 @@
extern "C" {
#endif
EXPORT bool btSoftBodySolver_checkInitialized(btSoftBodySolver* obj);
EXPORT void btSoftBodySolver_copyBackToSoftBodies(btSoftBodySolver* obj);
EXPORT void btSoftBodySolver_copyBackToSoftBodies2(btSoftBodySolver* obj, bool bMove);
EXPORT void btSoftBodySolver_copyBackToSoftBodies(btSoftBodySolver* obj, bool bMove);
EXPORT int btSoftBodySolver_getNumberOfPositionIterations(btSoftBodySolver* obj);
EXPORT int btSoftBodySolver_getNumberOfVelocityIterations(btSoftBodySolver* obj);
//EXPORT SolverTypes btSoftBodySolver_getSolverType(btSoftBodySolver* obj);
EXPORT float btSoftBodySolver_getTimeScale(btSoftBodySolver* obj);
//EXPORT void btSoftBodySolver_optimize(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies);
//EXPORT void btSoftBodySolver_optimize2(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies, bool forceUpdate);
//EXPORT void btSoftBodySolver_optimize(btSoftBodySolver* obj, btAlignedObjectArray_btSoftBodyPtr* softBodies, bool forceUpdate);
EXPORT void btSoftBodySolver_predictMotion(btSoftBodySolver* obj, float solverdt);
//EXPORT void btSoftBodySolver_processCollision(btSoftBodySolver* obj, btSoftBody* __unnamed0, const btCollisionObjectWrapper* __unnamed1);
//EXPORT void btSoftBodySolver_processCollision2(btSoftBodySolver* obj, btSoftBody* __unnamed0, btSoftBody* __unnamed1);

150
libbulletc/src/btSoftBody_wrap.cpp
Просмотреть файл

@ -2138,20 +2138,7 @@ void btSoftBody_addVelocity2(btSoftBody* obj, const btVector3* velocity, int nod
obj->addVelocity(BTVECTOR3_USE(velocity), node);
}
void btSoftBody_appendAnchor(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot)
{
BTVECTOR3_IN(localPivot);
obj->appendAnchor(node, body, BTVECTOR3_USE(localPivot));
}
void btSoftBody_appendAnchor2(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot,
bool disableCollisionBetweenLinkedBodies)
{
BTVECTOR3_IN(localPivot);
obj->appendAnchor(node, body, BTVECTOR3_USE(localPivot), disableCollisionBetweenLinkedBodies);
}
void btSoftBody_appendAnchor3(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot,
void btSoftBody_appendAnchor(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot,
bool disableCollisionBetweenLinkedBodies, btScalar influence)
{
BTVECTOR3_IN(localPivot);
@ -2159,17 +2146,7 @@ void btSoftBody_appendAnchor3(btSoftBody* obj, int node, btRigidBody* body, cons
influence);
}
void btSoftBody_appendAnchor4(btSoftBody* obj, int node, btRigidBody* body)
{
obj->appendAnchor(node, body);
}
void btSoftBody_appendAnchor5(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies)
{
obj->appendAnchor(node, body, disableCollisionBetweenLinkedBodies);
}
void btSoftBody_appendAnchor6(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies,
void btSoftBody_appendAnchor2(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies,
btScalar influence)
{
obj->appendAnchor(node, body, disableCollisionBetweenLinkedBodies, influence);
@ -2198,27 +2175,12 @@ void btSoftBody_appendAngularJoint4(btSoftBody* obj, const btSoftBody_AJoint_Spe
obj->appendAngularJoint(*specs, body0, *body1);
}
void btSoftBody_appendFace(btSoftBody* obj)
{
obj->appendFace();
}
void btSoftBody_appendFace2(btSoftBody* obj, int model)
{
obj->appendFace(model);
}
void btSoftBody_appendFace3(btSoftBody* obj, int model, btSoftBody_Material* mat)
void btSoftBody_appendFace(btSoftBody* obj, int model, btSoftBody_Material* mat)
{
obj->appendFace(model, mat);
}
void btSoftBody_appendFace4(btSoftBody* obj, int node0, int node1, int node2)
{
obj->appendFace(node0, node1, node2);
}
void btSoftBody_appendFace5(btSoftBody* obj, int node0, int node1, int node2, btSoftBody_Material* mat)
void btSoftBody_appendFace2(btSoftBody* obj, int node0, int node1, int node2, btSoftBody_Material* mat)
{
obj->appendFace(node0, node1, node2, mat);
}
@ -2246,49 +2208,18 @@ void btSoftBody_appendLinearJoint4(btSoftBody* obj, const btSoftBody_LJoint_Spec
obj->appendLinearJoint(*specs, body0, *body1);
}
void btSoftBody_appendLink(btSoftBody* obj, int node0, int node1)
{
obj->appendLink(node0, node1);
}
void btSoftBody_appendLink2(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat)
{
obj->appendLink(node0, node1, mat);
}
void btSoftBody_appendLink3(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat,
void btSoftBody_appendLink(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat,
bool bcheckexist)
{
obj->appendLink(node0, node1, mat, bcheckexist);
}
void btSoftBody_appendLink4(btSoftBody* obj)
{
obj->appendLink();
}
void btSoftBody_appendLink5(btSoftBody* obj, int model)
{
obj->appendLink(model);
}
void btSoftBody_appendLink6(btSoftBody* obj, int model, btSoftBody_Material* mat)
void btSoftBody_appendLink2(btSoftBody* obj, int model, btSoftBody_Material* mat)
{
obj->appendLink(model, mat);
}
void btSoftBody_appendLink7(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1)
{
obj->appendLink(node0, node1);
}
void btSoftBody_appendLink8(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1,
btSoftBody_Material* mat)
{
obj->appendLink(node0, node1, mat);
}
void btSoftBody_appendLink9(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1,
void btSoftBody_appendLink3(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1,
btSoftBody_Material* mat, bool bcheckexist)
{
obj->appendLink(node0, node1, mat, bcheckexist);
@ -2333,38 +2264,6 @@ void btSoftBody_appendNote4(btSoftBody* obj, const char* text, const btVector3*
}
void btSoftBody_appendNote5(btSoftBody* obj, const char* text, const btVector3* o,
const btVector4* c)
{
BTVECTOR3_IN(o);
BTVECTOR4_IN(c);
obj->appendNote(text, BTVECTOR3_USE(o), BTVECTOR4_USE(c));
}
void btSoftBody_appendNote6(btSoftBody* obj, const char* text, const btVector3* o,
const btVector4* c, btSoftBody_Node* n0)
{
BTVECTOR3_IN(o);
BTVECTOR4_IN(c);
obj->appendNote(text, BTVECTOR3_USE(o), BTVECTOR4_USE(c), n0);
}
void btSoftBody_appendNote7(btSoftBody* obj, const char* text, const btVector3* o,
const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1)
{
BTVECTOR3_IN(o);
BTVECTOR4_IN(c);
obj->appendNote(text, BTVECTOR3_USE(o), BTVECTOR4_USE(c), n0, n1);
}
void btSoftBody_appendNote8(btSoftBody* obj, const char* text, const btVector3* o,
const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1, btSoftBody_Node* n2)
{
BTVECTOR3_IN(o);
BTVECTOR4_IN(c);
obj->appendNote(text, BTVECTOR3_USE(o), BTVECTOR4_USE(c), n0, n1, n2);
}
void btSoftBody_appendNote9(btSoftBody* obj, const char* text, const btVector3* o,
const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1, btSoftBody_Node* n2,
btSoftBody_Node* n3)
{
@ -2378,12 +2277,7 @@ void btSoftBody_appendTetra(btSoftBody* obj, int model, btSoftBody_Material* mat
obj->appendTetra(model, mat);
}
void btSoftBody_appendTetra2(btSoftBody* obj, int node0, int node1, int node2, int node3)
{
obj->appendTetra(node0, node1, node2, node3);
}
void btSoftBody_appendTetra3(btSoftBody* obj, int node0, int node1, int node2, int node3,
void btSoftBody_appendTetra2(btSoftBody* obj, int node0, int node1, int node2, int node3,
btSoftBody_Material* mat)
{
obj->appendTetra(node0, node1, node2, node3, mat);
@ -2529,12 +2423,7 @@ void btSoftBody_evaluateCom(btSoftBody* obj, btVector3* value)
BTVECTOR3_SET(value, temp);
}
int btSoftBody_generateBendingConstraints(btSoftBody* obj, int distance)
{
return obj->generateBendingConstraints(distance);
}
int btSoftBody_generateBendingConstraints2(btSoftBody* obj, int distance, btSoftBody_Material* mat)
int btSoftBody_generateBendingConstraints(btSoftBody* obj, int distance, btSoftBody_Material* mat)
{
return obj->generateBendingConstraints(distance, mat);
}
@ -2729,12 +2618,7 @@ btSoftBodyWorldInfo* btSoftBody_getWorldInfo(btSoftBody* obj)
return obj->getWorldInfo();
}
void btSoftBody_indicesToPointers(btSoftBody* obj)
{
obj->indicesToPointers();
}
void btSoftBody_indicesToPointers2(btSoftBody* obj, const int* map)
void btSoftBody_indicesToPointers(btSoftBody* obj, const int* map)
{
obj->indicesToPointers(map);
}
@ -2894,12 +2778,7 @@ void btSoftBody_setTotalDensity(btSoftBody* obj, btScalar density)
obj->setTotalDensity(density);
}
void btSoftBody_setTotalMass(btSoftBody* obj, btScalar mass)
{
obj->setTotalMass(mass);
}
void btSoftBody_setTotalMass2(btSoftBody* obj, btScalar mass, bool fromfaces)
void btSoftBody_setTotalMass(btSoftBody* obj, btScalar mass, bool fromfaces)
{
obj->setTotalMass(mass, fromfaces);
}
@ -2973,12 +2852,7 @@ btSoftBody* btSoftBody_upcast(btCollisionObject* colObj)
return btSoftBody::upcast(colObj);
}
void btSoftBody_updateArea(btSoftBody* obj)
{
obj->updateArea();
}
void btSoftBody_updateArea2(btSoftBody* obj, bool averageArea)
void btSoftBody_updateArea(btSoftBody* obj, bool averageArea)
{
obj->updateArea(averageArea);
}

48
libbulletc/src/btSoftBody_wrap.h
Просмотреть файл

@ -477,48 +477,30 @@ extern "C" {
EXPORT void btSoftBody_addForce2(btSoftBody* obj, const btVector3* force, int node);
EXPORT void btSoftBody_addVelocity(btSoftBody* obj, const btVector3* velocity);
EXPORT void btSoftBody_addVelocity2(btSoftBody* obj, const btVector3* velocity, int node);
EXPORT void btSoftBody_appendAnchor(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot);
EXPORT void btSoftBody_appendAnchor2(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot, bool disableCollisionBetweenLinkedBodies);
EXPORT void btSoftBody_appendAnchor3(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot, bool disableCollisionBetweenLinkedBodies, btScalar influence);
EXPORT void btSoftBody_appendAnchor4(btSoftBody* obj, int node, btRigidBody* body);
EXPORT void btSoftBody_appendAnchor5(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies);
EXPORT void btSoftBody_appendAnchor6(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies, btScalar influence);
EXPORT void btSoftBody_appendAnchor(btSoftBody* obj, int node, btRigidBody* body, const btVector3* localPivot, bool disableCollisionBetweenLinkedBodies, btScalar influence);
EXPORT void btSoftBody_appendAnchor2(btSoftBody* obj, int node, btRigidBody* body, bool disableCollisionBetweenLinkedBodies, btScalar influence);
EXPORT void btSoftBody_appendAngularJoint(btSoftBody* obj, const btSoftBody_AJoint_Specs* specs);
EXPORT void btSoftBody_appendAngularJoint2(btSoftBody* obj, const btSoftBody_AJoint_Specs* specs, btSoftBody_Body* body);
EXPORT void btSoftBody_appendAngularJoint3(btSoftBody* obj, const btSoftBody_AJoint_Specs* specs, btSoftBody* body);
EXPORT void btSoftBody_appendAngularJoint4(btSoftBody* obj, const btSoftBody_AJoint_Specs* specs, btSoftBody_Cluster* body0, btSoftBody_Body* body1);
EXPORT void btSoftBody_appendFace(btSoftBody* obj);
EXPORT void btSoftBody_appendFace2(btSoftBody* obj, int model);
EXPORT void btSoftBody_appendFace3(btSoftBody* obj, int model, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendFace4(btSoftBody* obj, int node0, int node1, int node2);
EXPORT void btSoftBody_appendFace5(btSoftBody* obj, int node0, int node1, int node2, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendFace(btSoftBody* obj, int model, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendFace2(btSoftBody* obj, int node0, int node1, int node2, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendLinearJoint(btSoftBody* obj, const btSoftBody_LJoint_Specs* specs, btSoftBody* body);
EXPORT void btSoftBody_appendLinearJoint2(btSoftBody* obj, const btSoftBody_LJoint_Specs* specs);
EXPORT void btSoftBody_appendLinearJoint3(btSoftBody* obj, const btSoftBody_LJoint_Specs* specs, btSoftBody_Body* body);
EXPORT void btSoftBody_appendLinearJoint4(btSoftBody* obj, const btSoftBody_LJoint_Specs* specs, btSoftBody_Cluster* body0, btSoftBody_Body* body1);
EXPORT void btSoftBody_appendLink(btSoftBody* obj, int node0, int node1);
EXPORT void btSoftBody_appendLink2(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendLink3(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat, bool bcheckexist);
EXPORT void btSoftBody_appendLink4(btSoftBody* obj);
EXPORT void btSoftBody_appendLink5(btSoftBody* obj, int model);
EXPORT void btSoftBody_appendLink6(btSoftBody* obj, int model, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendLink7(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1);
EXPORT void btSoftBody_appendLink8(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendLink9(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1, btSoftBody_Material* mat, bool bcheckexist);
EXPORT void btSoftBody_appendLink(btSoftBody* obj, int node0, int node1, btSoftBody_Material* mat, bool bcheckexist);
EXPORT void btSoftBody_appendLink2(btSoftBody* obj, int model, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendLink3(btSoftBody* obj, btSoftBody_Node* node0, btSoftBody_Node* node1, btSoftBody_Material* mat, bool bcheckexist);
EXPORT btSoftBody_Material* btSoftBody_appendMaterial(btSoftBody* obj);
EXPORT void btSoftBody_appendNode(btSoftBody* obj, const btVector3* x, btScalar m);
EXPORT void btSoftBody_appendNote(btSoftBody* obj, const char* text, const btVector3* o, btSoftBody_Face* feature);
EXPORT void btSoftBody_appendNote2(btSoftBody* obj, const char* text, const btVector3* o, btSoftBody_Link* feature);
EXPORT void btSoftBody_appendNote3(btSoftBody* obj, const char* text, const btVector3* o, btSoftBody_Node* feature);
EXPORT void btSoftBody_appendNote4(btSoftBody* obj, const char* text, const btVector3* o);
EXPORT void btSoftBody_appendNote5(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c);
EXPORT void btSoftBody_appendNote6(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c, btSoftBody_Node* n0);
EXPORT void btSoftBody_appendNote7(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1);
EXPORT void btSoftBody_appendNote8(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1, btSoftBody_Node* n2);
EXPORT void btSoftBody_appendNote9(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1, btSoftBody_Node* n2, btSoftBody_Node* n3);
EXPORT void btSoftBody_appendNote5(btSoftBody* obj, const char* text, const btVector3* o, const btVector4* c, btSoftBody_Node* n0, btSoftBody_Node* n1, btSoftBody_Node* n2, btSoftBody_Node* n3);
EXPORT void btSoftBody_appendTetra(btSoftBody* obj, int model, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendTetra2(btSoftBody* obj, int node0, int node1, int node2, int node3);
EXPORT void btSoftBody_appendTetra3(btSoftBody* obj, int node0, int node1, int node2, int node3, btSoftBody_Material* mat);
EXPORT void btSoftBody_appendTetra2(btSoftBody* obj, int node0, int node1, int node2, int node3, btSoftBody_Material* mat);
EXPORT void btSoftBody_applyClusters(btSoftBody* obj, bool drift);
EXPORT void btSoftBody_applyForces(btSoftBody* obj);
EXPORT bool btSoftBody_checkContact(btSoftBody* obj, const btCollisionObjectWrapper* colObjWrap, const btVector3* x, btScalar margin, btSoftBody_sCti* cti);
@ -543,8 +525,7 @@ extern "C" {
EXPORT void btSoftBody_defaultCollisionHandler(btSoftBody* obj, const btCollisionObjectWrapper* pcoWrap);
EXPORT void btSoftBody_defaultCollisionHandler2(btSoftBody* obj, btSoftBody* psb);
EXPORT void btSoftBody_evaluateCom(btSoftBody* obj, btVector3* value);
EXPORT int btSoftBody_generateBendingConstraints(btSoftBody* obj, int distance);
EXPORT int btSoftBody_generateBendingConstraints2(btSoftBody* obj, int distance, btSoftBody_Material* mat);
EXPORT int btSoftBody_generateBendingConstraints(btSoftBody* obj, int distance, btSoftBody_Material* mat);
EXPORT int btSoftBody_generateClusters(btSoftBody* obj, int k);
EXPORT int btSoftBody_generateClusters2(btSoftBody* obj, int k, int maxiterations);
EXPORT void btSoftBody_getAabb(btSoftBody* obj, btVector3* aabbMin, btVector3* aabbMax);
@ -582,8 +563,7 @@ extern "C" {
EXPORT void btSoftBody_getWindVelocity(btSoftBody* obj, btVector3* velocity);
EXPORT btScalar btSoftBody_getVolume(btSoftBody* obj);
EXPORT btSoftBodyWorldInfo* btSoftBody_getWorldInfo(btSoftBody* obj);
EXPORT void btSoftBody_indicesToPointers(btSoftBody* obj);
EXPORT void btSoftBody_indicesToPointers2(btSoftBody* obj, const int* map);
EXPORT void btSoftBody_indicesToPointers(btSoftBody* obj, const int* map);
EXPORT void btSoftBody_initDefaults(btSoftBody* obj);
EXPORT void btSoftBody_initializeClusters(btSoftBody* obj);
EXPORT void btSoftBody_initializeFaceTree(btSoftBody* obj);
@ -614,8 +594,7 @@ extern "C" {
EXPORT void btSoftBody_setTag(btSoftBody* obj, void* value);
EXPORT void btSoftBody_setTimeacc(btSoftBody* obj, btScalar value);
EXPORT void btSoftBody_setTotalDensity(btSoftBody* obj, btScalar density);
EXPORT void btSoftBody_setTotalMass(btSoftBody* obj, btScalar mass);
EXPORT void btSoftBody_setTotalMass2(btSoftBody* obj, btScalar mass, bool fromfaces);
EXPORT void btSoftBody_setTotalMass(btSoftBody* obj, btScalar mass, bool fromfaces);
EXPORT void btSoftBody_setVelocity(btSoftBody* obj, const btVector3* velocity);
EXPORT void btSoftBody_setWindVelocity(btSoftBody* obj, const btVector3* velocity);
EXPORT void btSoftBody_setVolumeDensity(btSoftBody* obj, btScalar density);
@ -629,8 +608,7 @@ extern "C" {
EXPORT void btSoftBody_transform(btSoftBody* obj, const btTransform* trs);
EXPORT void btSoftBody_translate(btSoftBody* obj, const btVector3* trs);
EXPORT btSoftBody* btSoftBody_upcast(btCollisionObject* colObj);
EXPORT void btSoftBody_updateArea(btSoftBody* obj);
EXPORT void btSoftBody_updateArea2(btSoftBody* obj, bool averageArea);
EXPORT void btSoftBody_updateArea(btSoftBody* obj, bool averageArea);
EXPORT void btSoftBody_updateBounds(btSoftBody* obj);
EXPORT void btSoftBody_updateClusters(btSoftBody* obj);
EXPORT void btSoftBody_updateConstants(btSoftBody* obj);

7
libbulletc/src/btSoftRigidDynamicsWorld_wrap.cpp
Просмотреть файл

@ -6,13 +6,6 @@
#include "btSoftRigidDynamicsWorld_wrap.h"
btSoftRigidDynamicsWorld* btSoftRigidDynamicsWorld_new(btDispatcher* dispatcher,
btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration)
{
return new btSoftRigidDynamicsWorld(dispatcher, pairCache, constraintSolver,
collisionConfiguration);
}
btSoftRigidDynamicsWorld* btSoftRigidDynamicsWorld_new2(btDispatcher* dispatcher,
btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration,
btSoftBodySolver* softBodySolver)
{

3
libbulletc/src/btSoftRigidDynamicsWorld_wrap.h
Просмотреть файл

@ -3,8 +3,7 @@
#ifdef __cplusplus
extern "C" {
#endif
EXPORT btSoftRigidDynamicsWorld* btSoftRigidDynamicsWorld_new(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration);
EXPORT btSoftRigidDynamicsWorld* btSoftRigidDynamicsWorld_new2(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btSoftBodySolver* softBodySolver);
EXPORT btSoftRigidDynamicsWorld* btSoftRigidDynamicsWorld_new(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btConstraintSolver* constraintSolver, btCollisionConfiguration* collisionConfiguration, btSoftBodySolver* softBodySolver);
EXPORT void btSoftRigidDynamicsWorld_addSoftBody(btSoftRigidDynamicsWorld* obj, btSoftBody* body);
EXPORT void btSoftRigidDynamicsWorld_addSoftBody2(btSoftRigidDynamicsWorld* obj, btSoftBody* body, short collisionFilterGroup);
EXPORT void btSoftRigidDynamicsWorld_addSoftBody3(btSoftRigidDynamicsWorld* obj, btSoftBody* body, short collisionFilterGroup, short collisionFilterMask);

15
libbulletc/src/btSparseSdf3_wrap.cpp
Просмотреть файл

@ -12,26 +12,11 @@ void btSparseSdf3_GarbageCollect(btSparseSdf_3* obj, int lifetime)
obj->GarbageCollect(lifetime);
}
void btSparseSdf3_GarbageCollect2(btSparseSdf_3* obj)
{
obj->GarbageCollect();
}
void btSparseSdf3_Initialize(btSparseSdf_3* obj, int hashsize, int clampCells)
{
obj->Initialize(hashsize, clampCells);
}
void btSparseSdf3_Initialize2(btSparseSdf_3* obj, int hashsize)
{
obj->Initialize(hashsize);
}
void btSparseSdf3_Initialize3(btSparseSdf_3* obj)
{
obj->Initialize();
}
int btSparseSdf3_RemoveReferences(btSparseSdf_3* obj, btCollisionShape* pcs)
{
return obj->RemoveReferences(pcs);

3
libbulletc/src/btSparseSdf3_wrap.h
Просмотреть файл

@ -5,10 +5,7 @@ extern "C" {
#endif
EXPORT btSparseSdf_3* btSparseSdf_new();
EXPORT void btSparseSdf3_GarbageCollect(btSparseSdf_3* obj, int lifetime);
EXPORT void btSparseSdf3_GarbageCollect2(btSparseSdf_3* obj);
EXPORT void btSparseSdf3_Initialize(btSparseSdf_3* obj, int hashsize, int clampCells);
EXPORT void btSparseSdf3_Initialize2(btSparseSdf_3* obj, int hashsize);
EXPORT void btSparseSdf3_Initialize3(btSparseSdf_3* obj);
EXPORT int btSparseSdf3_RemoveReferences(btSparseSdf_3* obj, btCollisionShape* pcs);
EXPORT void btSparseSdf3_Reset(btSparseSdf_3* obj);
EXPORT void btSparseSdf_delete(btSparseSdf_3* obj);

18
libbulletc/src/btTypedConstraint_wrap.cpp
Просмотреть файл

@ -497,23 +497,7 @@ bool btAngularLimit_isLimit(btAngularLimit* obj)
return obj->isLimit();
}
void btAngularLimit_set(btAngularLimit* obj, btScalar low, btScalar high)
{
obj->set(low, high);
}
void btAngularLimit_set2(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness)
{
obj->set(low, high, _softness);
}
void btAngularLimit_set3(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness,
btScalar _biasFactor)
{
obj->set(low, high, _softness, _biasFactor);
}
void btAngularLimit_set4(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness,
void btAngularLimit_set(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness,
btScalar _biasFactor, btScalar _relaxationFactor)
{
obj->set(low, high, _softness, _biasFactor, _relaxationFactor);

5
libbulletc/src/btTypedConstraint_wrap.h
Просмотреть файл

@ -101,10 +101,7 @@ extern "C" {
EXPORT btScalar btAngularLimit_getSign(btAngularLimit* obj);
EXPORT btScalar btAngularLimit_getSoftness(btAngularLimit* obj);
EXPORT bool btAngularLimit_isLimit(btAngularLimit* obj);
EXPORT void btAngularLimit_set(btAngularLimit* obj, btScalar low, btScalar high);
EXPORT void btAngularLimit_set2(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness);
EXPORT void btAngularLimit_set3(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor);
EXPORT void btAngularLimit_set4(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor);
EXPORT void btAngularLimit_set(btAngularLimit* obj, btScalar low, btScalar high, btScalar _softness, btScalar _biasFactor, btScalar _relaxationFactor);
EXPORT void btAngularLimit_test(btAngularLimit* obj, btScalar angle);
EXPORT void btAngularLimit_delete(btAngularLimit* obj);
#ifdef __cplusplus