OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BulletSim: another round of conversion: dynamics world and collision object functions.

0.7.5-pf-bulletsim
Robert Adams 2012-12-30 10:21:47 -08:00
parent 9fd0e1b080
commit 9218748321
15 changed files with 1454 additions and 1248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

501
OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs
View File

@ -1,4 +1,4 @@
/*
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
@ -65,55 +65,55 @@ public override BulletShape CreateMeshShape(BulletWorld world,
int verticesCount, float[] vertices)
{
return new BulletShape(
BSAPI.CreateMeshShape2(world.ptr, indicesCount, indices, verticesCount, vertices),
BSAPICPP.CreateMeshShape2(world.ptr, indicesCount, indices, verticesCount, vertices),
BSPhysicsShapeType.SHAPE_MESH);
}
public override BulletShape CreateHullShape(BulletWorld world, int hullCount, float[] hulls)
{
return new BulletShape(
BSAPI.CreateHullShape2(world.ptr, hullCount, hulls),
BSAPICPP.CreateHullShape2(world.ptr, hullCount, hulls),
BSPhysicsShapeType.SHAPE_HULL);
}
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
{
return new BulletShape(
BSAPI.BuildHullShapeFromMesh2(world.ptr, meshShape.ptr),
BSAPICPP.BuildHullShapeFromMesh2(world.ptr, meshShape.ptr),
BSPhysicsShapeType.SHAPE_HULL);
}
public override BulletShape BuildNativeShape( BulletWorld world, ShapeData shapeData)
{
return new BulletShape(
BSAPI.BuildNativeShape2(world.ptr, shapeData),
BSAPICPP.BuildNativeShape2(world.ptr, shapeData),
shapeData.Type);
}
public override bool IsNativeShape(BulletShape shape)
{
if (shape.HasPhysicalShape)
return BSAPI.IsNativeShape2(shape.ptr);
return BSAPICPP.IsNativeShape2(shape.ptr);
return false;
}
public override void SetShapeCollisionMargin(BulletShape shape, float margin)
{
if (shape.HasPhysicalShape)
BSAPI.SetShapeCollisionMargin2(shape.ptr, margin);
BSAPICPP.SetShapeCollisionMargin2(shape.ptr, margin);
}
public override BulletShape BuildCapsuleShape(BulletWorld world, float radius, float height, Vector3 scale)
{
return new BulletShape(
BSAPI.BuildCapsuleShape2(world.ptr, radius, height, scale),
BSAPICPP.BuildCapsuleShape2(world.ptr, radius, height, scale),
BSPhysicsShapeType.SHAPE_CAPSULE);
}
public override BulletShape CreateCompoundShape(BulletWorld sim, bool enableDynamicAabbTree)
{
return new BulletShape(
BSAPI.CreateCompoundShape2(sim.ptr, enableDynamicAabbTree),
BSAPICPP.CreateCompoundShape2(sim.ptr, enableDynamicAabbTree),
BSPhysicsShapeType.SHAPE_COMPOUND);
}
@ -121,244 +121,455 @@ public override BulletShape CreateCompoundShape(BulletWorld sim, bool enableDyna
public override int GetNumberOfCompoundChildren(BulletShape shape)
{
if (shape.HasPhysicalShape)
return BSAPI.GetNumberOfCompoundChildren2(shape.ptr);
return BSAPICPP.GetNumberOfCompoundChildren2(shape.ptr);
return 0;
}
public override void AddChildShapeToCompoundShape(BulletShape cShape, BulletShape addShape, Vector3 pos, Quaternion rot)
{
BSAPI.AddChildShapeToCompoundShape2(cShape.ptr, addShape.ptr, pos, rot);
BSAPICPP.AddChildShapeToCompoundShape2(cShape.ptr, addShape.ptr, pos, rot);
}
public override BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx)
{
return new BulletShape(BSAPI.GetChildShapeFromCompoundShapeIndex2(cShape.ptr, indx));
return new BulletShape(BSAPICPP.GetChildShapeFromCompoundShapeIndex2(cShape.ptr, indx));
}
public override BulletShape RemoveChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx)
{
return new BulletShape(BSAPI.RemoveChildShapeFromCompoundShapeIndex2(cShape.ptr, indx));
return new BulletShape(BSAPICPP.RemoveChildShapeFromCompoundShapeIndex2(cShape.ptr, indx));
}
public override void RemoveChildShapeFromCompoundShape(BulletShape cShape, BulletShape removeShape)
{
BSAPI.RemoveChildShapeFromCompoundShape2(cShape.ptr, removeShape.ptr);
BSAPICPP.RemoveChildShapeFromCompoundShape2(cShape.ptr, removeShape.ptr);
}
public override void RecalculateCompoundShapeLocalAabb(BulletShape cShape)
{
BSAPI.RecalculateCompoundShapeLocalAabb2(cShape.ptr);
BSAPICPP.RecalculateCompoundShapeLocalAabb2(cShape.ptr);
}
public override BulletShape DuplicateCollisionShape(BulletWorld sim, BulletShape srcShape, uint id)
{
return new BulletShape(BSAPI.DuplicateCollisionShape2(sim.ptr, srcShape.ptr, id), srcShape.type);
return new BulletShape(BSAPICPP.DuplicateCollisionShape2(sim.ptr, srcShape.ptr, id), srcShape.type);
}
public override BulletBody CreateBodyFromShapeAndInfo(BulletWorld sim, BulletShape shape, uint id, IntPtr constructionInfo)
{
return new BulletBody(id, BSAPI.CreateBodyFromShapeAndInfo2(sim.ptr, shape.ptr, id, constructionInfo));
return new BulletBody(id, BSAPICPP.CreateBodyFromShapeAndInfo2(sim.ptr, shape.ptr, id, constructionInfo));
}
public override bool DeleteCollisionShape(BulletWorld world, BulletShape shape)
{
return BSAPI.DeleteCollisionShape2(world.ptr, shape.ptr);
return BSAPICPP.DeleteCollisionShape2(world.ptr, shape.ptr);
}
public override int GetBodyType(BulletBody obj)
{
return BSAPI.GetBodyType2(obj.ptr);
return BSAPICPP.GetBodyType2(obj.ptr);
}
public override BulletBody CreateBodyFromShape(BulletWorld sim, BulletShape shape, uint id, Vector3 pos, Quaternion rot)
{
return new BulletBody(id, BSAPI.CreateBodyFromShape2(sim.ptr, shape.ptr, id, pos, rot));
return new BulletBody(id, BSAPICPP.CreateBodyFromShape2(sim.ptr, shape.ptr, id, pos, rot));
}
public override BulletBody CreateBodyWithDefaultMotionState(BulletShape shape, uint id, Vector3 pos, Quaternion rot)
{
return new BulletBody(id, BSAPI.CreateBodyWithDefaultMotionState2(shape.ptr, id, pos, rot));
return new BulletBody(id, BSAPICPP.CreateBodyWithDefaultMotionState2(shape.ptr, id, pos, rot));
}
public override BulletBody CreateGhostFromShape(BulletWorld sim, BulletShape shape, uint id, Vector3 pos, Quaternion rot)
{
return new BulletBody(id, BSAPI.CreateGhostFromShape2(sim.ptr, shape.ptr, id, pos, rot));
return new BulletBody(id, BSAPICPP.CreateGhostFromShape2(sim.ptr, shape.ptr, id, pos, rot));
}
public override IntPtr AllocateBodyInfo(BulletBody obj)
{
return BSAPI.AllocateBodyInfo2(obj.ptr);
return BSAPICPP.AllocateBodyInfo2(obj.ptr);
}
public override void ReleaseBodyInfo(IntPtr obj)
{
BSAPI.ReleaseBodyInfo2(obj);
BSAPICPP.ReleaseBodyInfo2(obj);
}
public override void DestroyObject(BulletWorld sim, BulletBody obj)
{
BSAPI.DestroyObject2(sim.ptr, obj.ptr);
BSAPICPP.DestroyObject2(sim.ptr, obj.ptr);
}
/*
// =====================================================================================
// Terrain creation and helper routines
public override IntPtr CreateHeightMapInfo(BulletWorld sim, uint id, Vector3 minCoords, Vector3 maxCoords,
[MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin);
float[] heightMap, float collisionMargin)
{
return BSAPICPP.CreateHeightMapInfo2(sim.ptr, id, minCoords, maxCoords, heightMap, collisionMargin);
}
public override IntPtr FillHeightMapInfo(BulletWorld sim, IntPtr mapInfo, uint id, Vector3 minCoords, Vector3 maxCoords,
[MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin);
float[] heightMap, float collisionMargin)
{
return BSAPICPP.FillHeightMapInfo2(sim.ptr, mapInfo, id, minCoords, maxCoords, heightMap, collisionMargin);
}
public override bool ReleaseHeightMapInfo(IntPtr heightMapInfo);
public override bool ReleaseHeightMapInfo(IntPtr heightMapInfo)
{
return BSAPICPP.ReleaseHeightMapInfo2(heightMapInfo);
}
public override BulletBody CreateGroundPlaneShape(uint id, float height, float collisionMargin);
public override BulletShape CreateGroundPlaneShape(uint id, float height, float collisionMargin)
{
return new BulletShape(BSAPICPP.CreateGroundPlaneShape2(id, height, collisionMargin), BSPhysicsShapeType.SHAPE_GROUNDPLANE);
}
public override BulletBody CreateTerrainShape(IntPtr mapInfo);
public override BulletShape CreateTerrainShape(IntPtr mapInfo)
{
return new BulletShape(BSAPICPP.CreateTerrainShape2(mapInfo), BSPhysicsShapeType.SHAPE_TERRAIN);
}
// =====================================================================================
// Constraint creation and helper routines
public override BulletConstraint Create6DofConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 frame1loc, Quaternion frame1rot,
Vector3 frame2loc, Quaternion frame2rot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
{
return new BulletConstraint(BSAPICPP.Create6DofConstraint2(world.ptr, obj1.ptr, obj2.ptr, frame1loc, frame1rot,
frame2loc, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
}
public override BulletConstraint Create6DofConstraintToPoint(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 joinPoint,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
{
return new BulletConstraint(BSAPICPP.Create6DofConstraintToPoint2(world.ptr, obj1.ptr, obj2.ptr,
joinPoint, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
}
public override BulletConstraint CreateHingeConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 pivotinA, Vector3 pivotinB,
Vector3 axisInA, Vector3 axisInB,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
{
return new BulletConstraint(BSAPICPP.CreateHingeConstraint2(world.ptr, obj1.ptr, obj2.ptr,
pivotinA, pivotinB, axisInA, axisInB, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
}
public override void SetConstraintEnable(BulletConstraint constrain, float numericTrueFalse);
public override void SetConstraintEnable(BulletConstraint constrain, float numericTrueFalse)
{
BSAPICPP.SetConstraintEnable2(constrain.ptr, numericTrueFalse);
}
public override void SetConstraintNumSolverIterations(BulletConstraint constrain, float iterations);
public override void SetConstraintNumSolverIterations(BulletConstraint constrain, float iterations)
{
BSAPICPP.SetConstraintNumSolverIterations2(constrain.ptr, iterations);
}
public override bool SetFrames(BulletConstraint constrain,
Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot);
Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot)
{
return BSAPICPP.SetFrames2(constrain.ptr, frameA, frameArot, frameB, frameBrot);
}
public override bool SetLinearLimits(BulletConstraint constrain, Vector3 low, Vector3 hi);
public override bool SetLinearLimits(BulletConstraint constrain, Vector3 low, Vector3 hi)
{
return BSAPICPP.SetLinearLimits2(constrain.ptr, low, hi);
}
public override bool SetAngularLimits(BulletConstraint constrain, Vector3 low, Vector3 hi);
public override bool SetAngularLimits(BulletConstraint constrain, Vector3 low, Vector3 hi)
{
return BSAPICPP.SetAngularLimits2(constrain.ptr, low, hi);
}
public override bool UseFrameOffset(BulletConstraint constrain, float enable);
public override bool UseFrameOffset(BulletConstraint constrain, float enable)
{
return BSAPICPP.UseFrameOffset2(constrain.ptr, enable);
}
public override bool TranslationalLimitMotor(BulletConstraint constrain, float enable, float targetVel, float maxMotorForce);
public override bool TranslationalLimitMotor(BulletConstraint constrain, float enable, float targetVel, float maxMotorForce)
{
return BSAPICPP.TranslationalLimitMotor2(constrain.ptr, enable, targetVel, maxMotorForce);
}
public override bool SetBreakingImpulseThreshold(BulletConstraint constrain, float threshold);
public override bool SetBreakingImpulseThreshold(BulletConstraint constrain, float threshold)
{
return BSAPICPP.SetBreakingImpulseThreshold2(constrain.ptr, threshold);
}
public override bool CalculateTransforms(BulletConstraint constrain);
public override bool CalculateTransforms(BulletConstraint constrain)
{
return BSAPICPP.CalculateTransforms2(constrain.ptr);
}
public override bool SetConstraintParam(BulletConstraint constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis);
public override bool SetConstraintParam(BulletConstraint constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis)
{
return BSAPICPP.SetConstraintParam2(constrain.ptr, paramIndex, value, axis);
}
public override bool DestroyConstraint(BulletWorld world, BulletConstraint constrain);
public override bool DestroyConstraint(BulletWorld world, BulletConstraint constrain)
{
return BSAPICPP.DestroyConstraint2(world.ptr, constrain.ptr);
}
// =====================================================================================
// btCollisionWorld entries
public override void UpdateSingleAabb(BulletWorld world, BulletBody obj);
public override void UpdateSingleAabb(BulletWorld world, BulletBody obj)
{
BSAPICPP.UpdateSingleAabb2(world.ptr, obj.ptr);
}
public override void UpdateAabbs(BulletWorld world);
public override void UpdateAabbs(BulletWorld world)
{
BSAPICPP.UpdateAabbs2(world.ptr);
}
public override bool GetForceUpdateAllAabbs(BulletWorld world);
public override bool GetForceUpdateAllAabbs(BulletWorld world)
{
return BSAPICPP.GetForceUpdateAllAabbs2(world.ptr);
}
public override void SetForceUpdateAllAabbs(BulletWorld world, bool force);
public override void SetForceUpdateAllAabbs(BulletWorld world, bool force)
{
BSAPICPP.SetForceUpdateAllAabbs2(world.ptr, force);
}
// =====================================================================================
// btDynamicsWorld entries
public override bool AddObjectToWorld(BulletWorld world, BulletBody obj);
public override bool AddObjectToWorld(BulletWorld world, BulletBody obj)
{
return BSAPICPP.AddObjectToWorld2(world.ptr, obj.ptr);
}
public override bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj);
public override bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj)
{
return BSAPICPP.RemoveObjectFromWorld2(world.ptr, obj.ptr);
}
public override bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects);
public override bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects)
{
return BSAPICPP.AddConstraintToWorld2(world.ptr, constrain.ptr, disableCollisionsBetweenLinkedObjects);
}
public override bool RemoveConstraintFromWorld(BulletWorld world, BulletConstraint constrain);
public override bool RemoveConstraintFromWorld(BulletWorld world, BulletConstraint constrain)
{
return BSAPICPP.RemoveConstraintFromWorld2(world.ptr, constrain.ptr);
}
// =====================================================================================
// btCollisionObject entries
public override Vector3 GetAnisotripicFriction(BulletConstraint constrain);
public override Vector3 GetAnisotripicFriction(BulletConstraint constrain)
{
return BSAPICPP.GetAnisotripicFriction2(constrain.ptr);
}
public override Vector3 SetAnisotripicFriction(BulletConstraint constrain, Vector3 frict);
public override Vector3 SetAnisotripicFriction(BulletConstraint constrain, Vector3 frict)
{
return BSAPICPP.SetAnisotripicFriction2(constrain.ptr, frict);
}
public override bool HasAnisotripicFriction(BulletConstraint constrain);
public override bool HasAnisotripicFriction(BulletConstraint constrain)
{
return BSAPICPP.HasAnisotripicFriction2(constrain.ptr);
}
public override void SetContactProcessingThreshold(BulletBody obj, float val);
public override void SetContactProcessingThreshold(BulletBody obj, float val)
{
BSAPICPP.SetContactProcessingThreshold2(obj.ptr, val);
}
public override float GetContactProcessingThreshold(BulletBody obj);
public override float GetContactProcessingThreshold(BulletBody obj)
{
return BSAPICPP.GetContactProcessingThreshold2(obj.ptr);
}
public override bool IsStaticObject(BulletBody obj);
public override bool IsStaticObject(BulletBody obj)
{
return BSAPICPP.IsStaticObject2(obj.ptr);
}
public override bool IsKinematicObject(BulletBody obj);
public override bool IsKinematicObject(BulletBody obj)
{
return BSAPICPP.IsKinematicObject2(obj.ptr);
}
public override bool IsStaticOrKinematicObject(BulletBody obj);
public override bool IsStaticOrKinematicObject(BulletBody obj)
{
return BSAPICPP.IsStaticOrKinematicObject2(obj.ptr);
}
public override bool HasContactResponse(BulletBody obj);
public override bool HasContactResponse(BulletBody obj)
{
return BSAPICPP.HasContactResponse2(obj.ptr);
}
public override void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletBody shape);
public override void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletShape shape)
{
BSAPICPP.SetCollisionShape2(sim.ptr, obj.ptr, shape.ptr);
}
public override BulletShape GetCollisionShape(BulletBody obj);
public override BulletShape GetCollisionShape(BulletBody obj)
{
return new BulletShape(BSAPICPP.GetCollisionShape2(obj.ptr));
}
public override int GetActivationState(BulletBody obj);
public override int GetActivationState(BulletBody obj)
{
return BSAPICPP.GetActivationState2(obj.ptr);
}
public override void SetActivationState(BulletBody obj, int state);
public override void SetActivationState(BulletBody obj, int state)
{
BSAPICPP.SetActivationState2(obj.ptr, state);
}
public override void SetDeactivationTime(BulletBody obj, float dtime);
public override void SetDeactivationTime(BulletBody obj, float dtime)
{
BSAPICPP.SetDeactivationTime2(obj.ptr, dtime);
}
public override float GetDeactivationTime(BulletBody obj);
public override float GetDeactivationTime(BulletBody obj)
{
return BSAPICPP.GetDeactivationTime2(obj.ptr);
}
public override void ForceActivationState(BulletBody obj, ActivationState state);
public override void ForceActivationState(BulletBody obj, ActivationState state)
{
BSAPICPP.ForceActivationState2(obj.ptr, state);
}
public override void Activate(BulletBody obj, bool forceActivation);
public override void Activate(BulletBody obj, bool forceActivation)
{
BSAPICPP.Activate2(obj.ptr, forceActivation);
}
public override bool IsActive(BulletBody obj);
public override bool IsActive(BulletBody obj)
{
return BSAPICPP.IsActive2(obj.ptr);
}
public override void SetRestitution(BulletBody obj, float val);
public override void SetRestitution(BulletBody obj, float val)
{
BSAPICPP.SetRestitution2(obj.ptr, val);
}
public override float GetRestitution(BulletBody obj);
public override float GetRestitution(BulletBody obj)
{
return BSAPICPP.GetRestitution2(obj.ptr);
}
public override void SetFriction(BulletBody obj, float val);
public override void SetFriction(BulletBody obj, float val)
{
BSAPICPP.SetFriction2(obj.ptr, val);
}
public override float GetFriction(BulletBody obj);
public override float GetFriction(BulletBody obj)
{
return BSAPICPP.GetFriction2(obj.ptr);
}
public override Vector3 GetPosition(BulletBody obj);
public override Vector3 GetPosition(BulletBody obj)
{
return BSAPICPP.GetPosition2(obj.ptr);
}
public override Quaternion GetOrientation(BulletBody obj);
public override Quaternion GetOrientation(BulletBody obj)
{
return BSAPICPP.GetOrientation2(obj.ptr);
}
public override void SetTranslation(BulletBody obj, Vector3 position, Quaternion rotation);
public override void SetTranslation(BulletBody obj, Vector3 position, Quaternion rotation)
{
BSAPICPP.SetTranslation2(obj.ptr, position, rotation);
}
public override IntPtr GetBroadphaseHandle(BulletBody obj);
public override IntPtr GetBroadphaseHandle(BulletBody obj)
{
return BSAPICPP.GetBroadphaseHandle2(obj.ptr);
}
public override void SetBroadphaseHandle(BulletBody obj, IntPtr handle);
public override void SetBroadphaseHandle(BulletBody obj, IntPtr handle)
{
BSAPICPP.SetUserPointer2(obj.ptr, handle);
}
public override void SetInterpolationLinearVelocity(BulletBody obj, Vector3 vel);
public override void SetInterpolationLinearVelocity(BulletBody obj, Vector3 vel)
{
BSAPICPP.SetInterpolationLinearVelocity2(obj.ptr, vel);
}
public override void SetInterpolationAngularVelocity(BulletBody obj, Vector3 vel);
public override void SetInterpolationAngularVelocity(BulletBody obj, Vector3 vel)
{
BSAPICPP.SetInterpolationAngularVelocity2(obj.ptr, vel);
}
public override void SetInterpolationVelocity(BulletBody obj, Vector3 linearVel, Vector3 angularVel);
public override void SetInterpolationVelocity(BulletBody obj, Vector3 linearVel, Vector3 angularVel)
{
BSAPICPP.SetInterpolationVelocity2(obj.ptr, linearVel, angularVel);
}
public override float GetHitFraction(BulletBody obj);
public override float GetHitFraction(BulletBody obj)
{
return BSAPICPP.GetHitFraction2(obj.ptr);
}
public override void SetHitFraction(BulletBody obj, float val);
public override void SetHitFraction(BulletBody obj, float val)
{
BSAPICPP.SetHitFraction2(obj.ptr, val);
}
public override CollisionFlags GetCollisionFlags(BulletBody obj);
public override CollisionFlags GetCollisionFlags(BulletBody obj)
{
return BSAPICPP.GetCollisionFlags2(obj.ptr);
}
public override CollisionFlags SetCollisionFlags(BulletBody obj, CollisionFlags flags);
public override CollisionFlags SetCollisionFlags(BulletBody obj, CollisionFlags flags)
{
return BSAPICPP.SetCollisionFlags2(obj.ptr, flags);
}
public override CollisionFlags AddToCollisionFlags(BulletBody obj, CollisionFlags flags);
public override CollisionFlags AddToCollisionFlags(BulletBody obj, CollisionFlags flags)
{
return BSAPICPP.AddToCollisionFlags2(obj.ptr, flags);
}
public override CollisionFlags RemoveFromCollisionFlags(BulletBody obj, CollisionFlags flags);
public override CollisionFlags RemoveFromCollisionFlags(BulletBody obj, CollisionFlags flags)
{
return BSAPICPP.RemoveFromCollisionFlags2(obj.ptr, flags);
}
public override float GetCcdMotionThreshold(BulletBody obj);
public override float GetCcdMotionThreshold(BulletBody obj)
{
return BSAPICPP.GetCcdMotionThreshold2(obj.ptr);
}
public override void SetCcdMotionThreshold(BulletBody obj, float val);
public override float GetCcdSweptSphereRadius(BulletBody obj);
public override void SetCcdMotionThreshold(BulletBody obj, float val)
{
BSAPICPP.SetCcdMotionThreshold2(obj.ptr, val);
}
public override void SetCcdSweptSphereRadius(BulletBody obj, float val);
public override float GetCcdSweptSphereRadius(BulletBody obj)
{
return BSAPICPP.GetCcdSweptSphereRadius2(obj.ptr);
}
public override IntPtr GetUserPointer(BulletBody obj);
public override void SetCcdSweptSphereRadius(BulletBody obj, float val)
{
BSAPICPP.SetCcdSweptSphereRadius2(obj.ptr, val);
}
public override void SetUserPointer(BulletBody obj, IntPtr val);
public override IntPtr GetUserPointer(BulletBody obj)
{
return BSAPICPP.GetUserPointer2(obj.ptr);
}
public override void SetUserPointer(BulletBody obj, IntPtr val)
{
BSAPICPP.SetUserPointer2(obj.ptr, val);
}
/*
// =====================================================================================
// btRigidBody entries
public override void ApplyGravity(BulletBody obj);
@ -496,7 +707,7 @@ public override void SetMargin(BulletShape shape, float val);
public override float GetMargin(BulletShape shape);
*/
static class BSAPI
static class BSAPICPP
{
// =====================================================================================
// Mesh, hull, shape and body creation helper routines
@ -575,55 +786,6 @@ public static extern void ReleaseBodyInfo2(IntPtr obj);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void DestroyObject2(IntPtr sim, IntPtr obj);
}
}
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
static class BulletSimAPI {
// ===============================================================================
// Link back to the managed code for outputting log messages
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg);
// ===============================================================================
// Initialization and simulation
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
int maxCollisions, IntPtr collisionArray,
int maxUpdates, IntPtr updateArray,
DebugLogCallback logRoutine);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void SetHeightMap2(IntPtr world, float[] heightmap);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void Shutdown2(IntPtr sim);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep,
out int updatedEntityCount,
out IntPtr updatedEntitiesPtr,
out int collidersCount,
out IntPtr collidersPtr);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern bool PushUpdate2(IntPtr obj);
// =====================================================================================
// Terrain creation and helper routines
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
@ -867,6 +1029,55 @@ public static extern IntPtr GetUserPointer2(IntPtr obj);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void SetUserPointer2(IntPtr obj, IntPtr val);
}
}
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
// ===============================================================================
static class BulletSimAPI {
// ===============================================================================
// Link back to the managed code for outputting log messages
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg);
// ===============================================================================
// Initialization and simulation
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
int maxCollisions, IntPtr collisionArray,
int maxUpdates, IntPtr updateArray,
DebugLogCallback logRoutine);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void SetHeightMap2(IntPtr world, float[] heightmap);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern void Shutdown2(IntPtr sim);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep,
out int updatedEntityCount,
out IntPtr updatedEntitiesPtr,
out int collidersCount,
out IntPtr collidersPtr);
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
public static extern bool PushUpdate2(IntPtr obj);
// =====================================================================================
// btRigidBody entries
[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]

46
OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
View File

@ -137,7 +137,7 @@ public sealed class BSCharacter : BSPhysObject
private void SetPhysicalProperties()
{
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
ZeroMotion(true);
ForcePosition = _position;
@ -152,14 +152,14 @@ public sealed class BSCharacter : BSPhysObject
// Needs to be reset especially when an avatar is recreated after crossing a region boundry.
Flying = _flying;
BulletSimAPI.SetRestitution2(PhysBody.ptr, BSParam.AvatarRestitution);
PhysicsScene.PE.SetRestitution(PhysBody, BSParam.AvatarRestitution);
BulletSimAPI.SetMargin2(PhysShape.ptr, PhysicsScene.Params.collisionMargin);
BulletSimAPI.SetLocalScaling2(PhysShape.ptr, Scale);
BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, BSParam.ContactProcessingThreshold);
PhysicsScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
if (BSParam.CcdMotionThreshold > 0f)
{
BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, BSParam.CcdMotionThreshold);
BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, BSParam.CcdSweptSphereRadius);
PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
}
UpdatePhysicalMassProperties(RawMass, false);
@ -167,13 +167,13 @@ public sealed class BSCharacter : BSPhysObject
// Make so capsule does not fall over
BulletSimAPI.SetAngularFactorV2(PhysBody.ptr, OMV.Vector3.Zero);
BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_CHARACTER_OBJECT);
PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_CHARACTER_OBJECT);
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, PhysBody);
// BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ACTIVE_TAG);
BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_DEACTIVATION);
BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr);
// PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, PhysBody);
// Do this after the object has been added to the world
PhysBody.collisionType = CollisionType.Avatar;
@ -320,7 +320,7 @@ public sealed class BSCharacter : BSPhysObject
{
if (PhysBody.HasPhysicalBody)
{
BulletSimAPI.SetInterpolationAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero);
PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, OMV.Vector3.Zero);
BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero);
// The next also get rid of applied linear force but the linear velocity is untouched.
BulletSimAPI.ClearForces2(PhysBody.ptr);
@ -350,19 +350,19 @@ public sealed class BSCharacter : BSPhysObject
{
DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation);
if (PhysBody.HasPhysicalBody)
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
});
}
}
public override OMV.Vector3 ForcePosition {
get {
_position = BulletSimAPI.GetPosition2(PhysBody.ptr);
_position = PhysicsScene.PE.GetPosition(PhysBody);
return _position;
}
set {
_position = value;
PositionSanityCheck();
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
}
}
@ -418,7 +418,7 @@ public sealed class BSCharacter : BSPhysObject
{
DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation);
if (PhysBody.HasPhysicalBody)
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
});
ret = true;
}
@ -520,7 +520,7 @@ public sealed class BSCharacter : BSPhysObject
{
_currentFriction = BSParam.AvatarStandingFriction;
if (PhysBody.HasPhysicalBody)
BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction);
PhysicsScene.PE.SetFriction(PhysBody, _currentFriction);
}
}
else
@ -529,12 +529,12 @@ public sealed class BSCharacter : BSPhysObject
{
_currentFriction = BSParam.AvatarFriction;
if (PhysBody.HasPhysicalBody)
BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction);
PhysicsScene.PE.SetFriction(PhysBody, _currentFriction);
}
}
BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity);
BulletSimAPI.Activate2(PhysBody.ptr, true);
PhysicsScene.PE.Activate(PhysBody, true);
}
}
public override OMV.Vector3 Torque {
@ -576,7 +576,7 @@ public sealed class BSCharacter : BSPhysObject
{
get
{
_orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr);
_orientation = PhysicsScene.PE.GetOrientation(PhysBody);
return _orientation;
}
set
@ -584,8 +584,8 @@ public sealed class BSCharacter : BSPhysObject
_orientation = value;
if (PhysBody.HasPhysicalBody)
{
// _position = BulletSimAPI.GetPosition2(BSBody.ptr);
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
// _position = PhysicsScene.PE.GetPosition(BSBody);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
}
}
}
@ -636,9 +636,9 @@ public sealed class BSCharacter : BSPhysObject
if (PhysBody.HasPhysicalBody)
{
if (_floatOnWater)
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
else
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
}
});
}

17
OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
View File

@ -37,6 +37,7 @@ public abstract class BSConstraint : IDisposable
private static string LogHeader = "[BULLETSIM CONSTRAINT]";
protected BulletWorld m_world;
protected BSScene PhysicsScene;
protected BulletBody m_body1;
protected BulletBody m_body2;
protected BulletConstraint m_constraint;
@ -48,8 +49,10 @@ public abstract class BSConstraint : IDisposable
public abstract ConstraintType Type { get; }
public bool IsEnabled { get { return m_enabled; } }
public BSConstraint()
public BSConstraint(BulletWorld world)
{
m_world = world;
PhysicsScene = m_world.physicsScene;
}
public virtual void Dispose()
@ -59,7 +62,7 @@ public abstract class BSConstraint : IDisposable
m_enabled = false;
if (m_constraint.HasPhysicalConstraint)
{
bool success = BulletSimAPI.DestroyConstraint2(m_world.ptr, m_constraint.ptr);
bool success = PhysicsScene.PE.DestroyConstraint(m_world, m_constraint);
m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}",
BSScene.DetailLogZero,
m_body1.ID, m_body1.ptr.ToString("X"),
@ -74,7 +77,7 @@ public abstract class BSConstraint : IDisposable
{
bool ret = false;
if (m_enabled)
ret = BulletSimAPI.SetLinearLimits2(m_constraint.ptr, low, high);
ret = PhysicsScene.PE.SetLinearLimits(m_constraint, low, high);
return ret;
}
@ -82,7 +85,7 @@ public abstract class BSConstraint : IDisposable
{
bool ret = false;
if (m_enabled)
ret = BulletSimAPI.SetAngularLimits2(m_constraint.ptr, low, high);
ret = PhysicsScene.PE.SetAngularLimits(m_constraint, low, high);
return ret;
}
@ -91,7 +94,7 @@ public abstract class BSConstraint : IDisposable
bool ret = false;
if (m_enabled)
{
BulletSimAPI.SetConstraintNumSolverIterations2(m_constraint.ptr, cnt);
PhysicsScene.PE.SetConstraintNumSolverIterations(m_constraint, cnt);
ret = true;
}
return ret;
@ -103,7 +106,7 @@ public abstract class BSConstraint : IDisposable
if (m_enabled)
{
// Recompute the internal transforms
BulletSimAPI.CalculateTransforms2(m_constraint.ptr);
PhysicsScene.PE.CalculateTransforms(m_constraint);
ret = true;
}
return ret;
@ -122,7 +125,7 @@ public abstract class BSConstraint : IDisposable
// Setting an object's mass to zero (making it static like when it's selected)
// automatically disables the constraints.
// If the link is enabled, be sure to set the constraint itself to enabled.
BulletSimAPI.SetConstraintEnable2(m_constraint.ptr, BSParam.NumericBool(true));
PhysicsScene.PE.SetConstraintEnable(m_constraint, BSParam.NumericBool(true));
}
else
{

30
OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
View File

@ -43,15 +43,14 @@ public sealed class BSConstraint6Dof : BSConstraint
Vector3 frame1, Quaternion frame1rot,
Vector3 frame2, Quaternion frame2rot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_world = world;
m_body1 = obj1;
m_body2 = obj2;
m_constraint = new BulletConstraint(
BulletSimAPI.Create6DofConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
m_constraint = PhysicsScene.PE.Create6DofConstraint(m_world, m_body1, m_body2,
frame1, frame1rot,
frame2, frame2rot,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
world.physicsScene.DetailLog("{0},BS6DofConstraint,createFrame,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
BSScene.DetailLogZero, world.worldID,
@ -61,8 +60,8 @@ public sealed class BSConstraint6Dof : BSConstraint
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 joinPoint,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_world = world;
m_body1 = obj1;
m_body2 = obj2;
if (!obj1.HasPhysicalBody || !obj2.HasPhysicalBody)
@ -76,11 +75,10 @@ public sealed class BSConstraint6Dof : BSConstraint
}
else
{
m_constraint = new BulletConstraint(
BulletSimAPI.Create6DofConstraintToPoint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
m_constraint = PhysicsScene.PE.Create6DofConstraintToPoint(m_world, m_body1, m_body2,
joinPoint,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
world.physicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
PhysicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
BSScene.DetailLogZero, world.worldID, m_constraint.ptr.ToString("X"),
obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X"));
if (!m_constraint.HasPhysicalConstraint)
@ -101,7 +99,7 @@ public sealed class BSConstraint6Dof : BSConstraint
bool ret = false;
if (m_enabled)
{
BulletSimAPI.SetFrames2(m_constraint.ptr, frameA, frameArot, frameB, frameBrot);
PhysicsScene.PE.SetFrames(m_constraint, frameA, frameArot, frameB, frameBrot);
ret = true;
}
return ret;
@ -112,9 +110,9 @@ public sealed class BSConstraint6Dof : BSConstraint
bool ret = false;
if (m_enabled)
{
BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL);
BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL);
PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
ret = true;
}
return ret;
@ -125,7 +123,7 @@ public sealed class BSConstraint6Dof : BSConstraint
bool ret = false;
float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
if (m_enabled)
ret = BulletSimAPI.UseFrameOffset2(m_constraint.ptr, onOff);
ret = PhysicsScene.PE.UseFrameOffset(m_constraint, onOff);
return ret;
}
@ -135,7 +133,7 @@ public sealed class BSConstraint6Dof : BSConstraint
float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
if (m_enabled)
{
ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.ptr, onOff, targetVelocity, maxMotorForce);
ret = PhysicsScene.PE.TranslationalLimitMotor(m_constraint, onOff, targetVelocity, maxMotorForce);
m_world.physicsScene.DetailLog("{0},BS6DOFConstraint,TransLimitMotor,enable={1},vel={2},maxForce={3}",
BSScene.DetailLogZero, enable, targetVelocity, maxMotorForce);
}
@ -146,7 +144,7 @@ public sealed class BSConstraint6Dof : BSConstraint
{
bool ret = false;
if (m_enabled)
ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.ptr, threshold);
ret = PhysicsScene.PE.SetBreakingImpulseThreshold(m_constraint, threshold);
return ret;
}
}

10
OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs
View File

@ -40,15 +40,13 @@ public sealed class BSConstraintHinge : BSConstraint
Vector3 pivotInA, Vector3 pivotInB,
Vector3 axisInA, Vector3 axisInB,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_world = world;
m_body1 = obj1;
m_body2 = obj2;
m_constraint = new BulletConstraint(
BulletSimAPI.CreateHingeConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
pivotInA, pivotInB,
axisInA, axisInB,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
m_constraint = PhysicsScene.PE.CreateHingeConstraint(world, obj1, obj2,
pivotInA, pivotInB, axisInA, axisInB,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
}

10
OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
View File

@ -558,7 +558,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Friction affects are handled by this vehicle code
float friction = 0f;
BulletSimAPI.SetFriction2(Prim.PhysBody.ptr, friction);
PhysicsScene.PE.SetFriction(Prim.PhysBody, friction);
// Moderate angular movement introduced by Bullet.
// TODO: possibly set AngularFactor and LinearFactor for the type of vehicle.
@ -567,7 +567,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
BulletSimAPI.SetAngularDamping2(Prim.PhysBody.ptr, angularDamping);
// Vehicles report collision events so we know when it's on the ground
BulletSimAPI.AddToCollisionFlags2(Prim.PhysBody.ptr, CollisionFlags.BS_VEHICLE_COLLISIONS);
PhysicsScene.PE.AddToCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
Vector3 localInertia = BulletSimAPI.CalculateLocalInertia2(Prim.PhysShape.ptr, m_vehicleMass);
BulletSimAPI.SetMassProps2(Prim.PhysBody.ptr, m_vehicleMass, localInertia);
@ -581,7 +581,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
}
else
{
BulletSimAPI.RemoveFromCollisionFlags2(Prim.PhysBody.ptr, CollisionFlags.BS_VEHICLE_COLLISIONS);
PhysicsScene.PE.RemoveFromCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
}
}
@ -651,7 +651,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if ((m_knownChanged & m_knownChangedVelocity) != 0)
{
Prim.ForceVelocity = m_knownVelocity;
BulletSimAPI.SetInterpolationLinearVelocity2(Prim.PhysBody.ptr, VehicleVelocity);
PhysicsScene.PE.SetInterpolationLinearVelocity(Prim.PhysBody, VehicleVelocity);
}
if ((m_knownChanged & m_knownChangedForce) != 0)
@ -661,7 +661,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{
Prim.ForceRotationalVelocity = m_knownRotationalVelocity;
// Fake out Bullet by making it think the velocity is the same as last time.
BulletSimAPI.SetInterpolationAngularVelocity2(Prim.PhysBody.ptr, m_knownRotationalVelocity);
PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity);
}
if ((m_knownChanged & m_knownChangedRotationalForce) != 0)

10
OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
View File

@ -131,10 +131,10 @@ public sealed class BSLinksetCompound : BSLinkset
{
// The origional prims are removed from the world as the shape of the root compound
// shape takes over.
BulletSimAPI.AddToCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
BulletSimAPI.ForceActivationState2(child.PhysBody.ptr, ActivationState.DISABLE_SIMULATION);
PhysicsScene.PE.AddToCollisionFlags(child.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
PhysicsScene.PE.ForceActivationState(child.PhysBody, ActivationState.DISABLE_SIMULATION);
// We don't want collisions from the old linkset children.
BulletSimAPI.RemoveFromCollisionFlags2(child.PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
PhysicsScene.PE.RemoveFromCollisionFlags(child.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
child.PhysBody.collisionType = CollisionType.LinksetChild;
@ -159,12 +159,12 @@ public sealed class BSLinksetCompound : BSLinkset
else
{
// The non-physical children can come back to life.
BulletSimAPI.RemoveFromCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
PhysicsScene.PE.RemoveFromCollisionFlags(child.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
child.PhysBody.collisionType = CollisionType.LinksetChild;
// Don't force activation so setting of DISABLE_SIMULATION can stay if used.
BulletSimAPI.Activate2(child.PhysBody.ptr, false);
PhysicsScene.PE.Activate(child.PhysBody, false);
ret = true;
}
return ret;

8
OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
View File

@ -300,7 +300,7 @@ public static class BSParam
(s,cf,p,v) => { DeactivationTime = cf.GetFloat(p, v); },
(s) => { return DeactivationTime; },
(s,p,l,v) => { s.UpdateParameterObject((x)=>{DeactivationTime=x;}, p, l, v); },
(s,o,v) => { BulletSimAPI.SetDeactivationTime2(o.PhysBody.ptr, v); } ),
(s,o,v) => { s.PE.SetDeactivationTime(o.PhysBody, v); } ),
new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static",
0.8f,
(s,cf,p,v) => { LinearSleepingThreshold = cf.GetFloat(p, v); },
@ -318,19 +318,19 @@ public static class BSParam
(s,cf,p,v) => { CcdMotionThreshold = cf.GetFloat(p, v); },
(s) => { return CcdMotionThreshold; },
(s,p,l,v) => { s.UpdateParameterObject((x)=>{CcdMotionThreshold=x;}, p, l, v); },
(s,o,v) => { BulletSimAPI.SetCcdMotionThreshold2(o.PhysBody.ptr, v); } ),
(s,o,v) => { s.PE.SetCcdMotionThreshold(o.PhysBody, v); } ),
new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" ,
0f,
(s,cf,p,v) => { CcdSweptSphereRadius = cf.GetFloat(p, v); },
(s) => { return CcdSweptSphereRadius; },
(s,p,l,v) => { s.UpdateParameterObject((x)=>{CcdSweptSphereRadius=x;}, p, l, v); },
(s,o,v) => { BulletSimAPI.SetCcdSweptSphereRadius2(o.PhysBody.ptr, v); } ),
(s,o,v) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, v); } ),
new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" ,
0.1f,
(s,cf,p,v) => { ContactProcessingThreshold = cf.GetFloat(p, v); },
(s) => { return ContactProcessingThreshold; },
(s,p,l,v) => { s.UpdateParameterObject((x)=>{ContactProcessingThreshold=x;}, p, l, v); },
(s,o,v) => { BulletSimAPI.SetContactProcessingThreshold2(o.PhysBody.ptr, v); } ),
(s,o,v) => { s.PE.SetContactProcessingThreshold(o.PhysBody, v); } ),
new ParameterDefn("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
(float)BSTerrainPhys.TerrainImplementation.Mesh,

4
OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
View File

@ -308,7 +308,7 @@ public abstract class BSPhysObject : PhysicsActor
PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate()
{
if (PhysBody.HasPhysicalBody)
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
});
}
else
@ -324,7 +324,7 @@ public abstract class BSPhysObject : PhysicsActor
{
// Make sure there is a body there because sometimes destruction happens in an un-ideal order.
if (PhysBody.HasPhysicalBody)
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
});
}
// Return 'true' if the simulator wants collision events

74
OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
View File

@ -120,7 +120,7 @@ public sealed class BSPrim : BSPhysObject
{
CreateGeomAndObject(true);
CurrentCollisionFlags = BulletSimAPI.GetCollisionFlags2(PhysBody.ptr);
CurrentCollisionFlags = PhysicsScene.PE.GetCollisionFlags(PhysBody);
});
}
@ -265,7 +265,7 @@ public sealed class BSPrim : BSPhysObject
// DetailLog("{0},BSPrim.ZeroAngularMotion,call,rotVel={1}", LocalID, _rotationalVelocity);
if (PhysBody.HasPhysicalBody)
{
BulletSimAPI.SetInterpolationAngularVelocity2(PhysBody.ptr, _rotationalVelocity);
PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, _rotationalVelocity);
}
});
@ -318,14 +318,14 @@ public sealed class BSPrim : BSPhysObject
}
public override OMV.Vector3 ForcePosition {
get {
_position = BulletSimAPI.GetPosition2(PhysBody.ptr);
_position = PhysicsScene.PE.GetPosition(PhysBody);
return _position;
}
set {
_position = value;
if (PhysBody.HasPhysicalBody)
{
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
ActivateIfPhysical(false);
}
}
@ -419,7 +419,7 @@ public sealed class BSPrim : BSPhysObject
// Changing interesting properties doesn't change proxy and collision cache
// information. The Bullet solution is to re-add the object to the world
// after parameters are changed.
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
}
// The computation of mass props requires gravity to be set on the object.
@ -649,9 +649,9 @@ public sealed class BSPrim : BSPhysObject
{
if (PhysBody.HasPhysicalBody)
{
// _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr);
// _position = PhysicsScene.PE.GetObjectPosition(PhysicsScene.World, BSBody);
// DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation);
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
}
});
}
@ -661,13 +661,13 @@ public sealed class BSPrim : BSPhysObject
{
get
{
_orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr);
_orientation = PhysicsScene.PE.GetOrientation(PhysBody);
return _orientation;
}
set
{
_orientation = value;
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
}
}
public override int PhysicsActorType {
@ -723,7 +723,7 @@ public sealed class BSPrim : BSPhysObject
// Mangling all the physical properties requires the object not be in the physical world.
// This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found).
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
// Set up the object physicalness (does gravity and collisions move this object)
MakeDynamic(IsStatic);
@ -740,7 +740,7 @@ public sealed class BSPrim : BSPhysObject
AddObjectToPhysicalWorld();
// Rebuild its shape
BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, PhysBody);
// Recompute any linkset parameters.
// When going from non-physical to physical, this re-enables the constraints that
@ -762,28 +762,28 @@ public sealed class BSPrim : BSPhysObject
if (makeStatic)
{
// Become a Bullet 'static' object type
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
// Stop all movement
ZeroMotion(true);
// Set various physical properties so other object interact properly
MaterialAttributes matAttrib = BSMaterials.GetAttributes(Material, false);
BulletSimAPI.SetFriction2(PhysBody.ptr, matAttrib.friction);
BulletSimAPI.SetRestitution2(PhysBody.ptr, matAttrib.restitution);
PhysicsScene.PE.SetFriction(PhysBody, matAttrib.friction);
PhysicsScene.PE.SetRestitution(PhysBody, matAttrib.restitution);
// Mass is zero which disables a bunch of physics stuff in Bullet
UpdatePhysicalMassProperties(0f, false);
// Set collision detection parameters
if (BSParam.CcdMotionThreshold > 0f)
{
BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, BSParam.CcdMotionThreshold);
BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, BSParam.CcdSweptSphereRadius);
PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
}
// The activation state is 'disabled' so Bullet will not try to act on it.
// BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_SIMULATION);
// PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_SIMULATION);
// Start it out sleeping and physical actions could wake it up.
BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.ISLAND_SLEEPING);
PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ISLAND_SLEEPING);
// This collides like a static object
PhysBody.collisionType = CollisionType.Static;
@ -794,22 +794,22 @@ public sealed class BSPrim : BSPhysObject
else
{
// Not a Bullet static object
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
// Set various physical properties so other object interact properly
MaterialAttributes matAttrib = BSMaterials.GetAttributes(Material, true);
BulletSimAPI.SetFriction2(PhysBody.ptr, matAttrib.friction);
BulletSimAPI.SetRestitution2(PhysBody.ptr, matAttrib.restitution);
PhysicsScene.PE.SetFriction(PhysBody, matAttrib.friction);
PhysicsScene.PE.SetRestitution(PhysBody, matAttrib.restitution);
// per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382
// Since this can be called multiple times, only zero forces when becoming physical
// BulletSimAPI.ClearAllForces2(BSBody.ptr);
// PhysicsScene.PE.ClearAllForces(BSBody);
// For good measure, make sure the transform is set through to the motion state
BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
// Center of mass is at the center of the object
// DEBUG DEBUG BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody.ptr, _position, _orientation);
// DEBUG DEBUG BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody, _position, _orientation);
// A dynamic object has mass
UpdatePhysicalMassProperties(RawMass, false);
@ -817,22 +817,22 @@ public sealed class BSPrim : BSPhysObject
// Set collision detection parameters
if (BSParam.CcdMotionThreshold > 0f)
{
BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, BSParam.CcdMotionThreshold);
BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, BSParam.CcdSweptSphereRadius);
PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
}
// Various values for simulation limits
BulletSimAPI.SetDamping2(PhysBody.ptr, BSParam.LinearDamping, BSParam.AngularDamping);
BulletSimAPI.SetDeactivationTime2(PhysBody.ptr, BSParam.DeactivationTime);
PhysicsScene.PE.SetDeactivationTime(PhysBody, BSParam.DeactivationTime);
BulletSimAPI.SetSleepingThresholds2(PhysBody.ptr, BSParam.LinearSleepingThreshold, BSParam.AngularSleepingThreshold);
BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, BSParam.ContactProcessingThreshold);
PhysicsScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
// This collides like an object.
PhysBody.collisionType = CollisionType.Dynamic;
// Force activation of the object so Bullet will act on it.
// Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects.
BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.ACTIVE_TAG);
PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
// There might be special things needed for implementing linksets.
Linkset.MakeDynamic(this);
@ -853,7 +853,7 @@ public sealed class BSPrim : BSPhysObject
{
m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType);
}
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
}
else
{
@ -861,7 +861,7 @@ public sealed class BSPrim : BSPhysObject
{
m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType);
}
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
// Change collision info from a static object to a ghosty collision object
PhysBody.collisionType = CollisionType.VolumeDetect;
@ -874,7 +874,7 @@ public sealed class BSPrim : BSPhysObject
private void ActivateIfPhysical(bool forceIt)
{
if (IsPhysical && PhysBody.HasPhysicalBody)
BulletSimAPI.Activate2(PhysBody.ptr, forceIt);
PhysicsScene.PE.Activate(PhysBody, forceIt);
}
// Turn on or off the flag controlling whether collision events are returned to the simulator.
@ -882,11 +882,11 @@ public sealed class BSPrim : BSPhysObject
{
if (wantsCollisionEvents)
{
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
}
else
{
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
}
}
@ -897,7 +897,7 @@ public sealed class BSPrim : BSPhysObject
{
if (PhysBody.HasPhysicalBody)
{
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, PhysBody);
// TODO: Fix this. Total kludge because adding object to world resets its gravity to default.
// Replace this when the new AddObjectToWorld function is complete.
@ -941,9 +941,9 @@ public sealed class BSPrim : BSPhysObject
PhysicsScene.TaintedObject("BSPrim.setFloatOnWater", delegate()
{
if (_floatOnWater)
CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
else
CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
});
}
}

6
OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
View File

@ -143,7 +143,7 @@ public sealed class BSShapeCollection : IDisposable
{
if (!BulletSimAPI.IsInWorld2(body.ptr))
{
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, body.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, body);
if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body);
}
});
@ -168,12 +168,12 @@ public sealed class BSShapeCollection : IDisposable
if (BulletSimAPI.IsInWorld2(body.ptr))
{
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, body.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, body);
if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,removingFromWorld. Body={1}", body.ID, body);
}
// Zero any reference to the shape so it is not freed when the body is deleted.
BulletSimAPI.SetCollisionShape2(PhysicsScene.World.ptr, body.ptr, IntPtr.Zero);
PhysicsScene.PE.SetCollisionShape(PhysicsScene.World, body, new BulletShape());
PhysicsScene.PE.DestroyObject(PhysicsScene.World, body);
});
}

23
OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
View File

@ -91,13 +91,12 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
// Using the information in m_mapInfo, create the physical representation of the heightmap.
private void BuildHeightmapTerrain()
{
m_mapInfo.Ptr = BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, m_mapInfo.ID,
m_mapInfo.Ptr = PhysicsScene.PE.CreateHeightMapInfo(PhysicsScene.World, m_mapInfo.ID,
m_mapInfo.minCoords, m_mapInfo.maxCoords,
m_mapInfo.heightMap, BSParam.TerrainCollisionMargin);
// Create the terrain shape from the mapInfo
m_mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(m_mapInfo.Ptr),
BSPhysicsShapeType.SHAPE_TERRAIN);
m_mapInfo.terrainShape = PhysicsScene.PE.CreateTerrainShape(m_mapInfo.Ptr);
// The terrain object initial position is at the center of the object
Vector3 centerPos;
@ -109,22 +108,22 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
m_mapInfo.ID, centerPos, Quaternion.Identity);
// Set current terrain attributes
BulletSimAPI.SetFriction2(m_mapInfo.terrainBody.ptr, BSParam.TerrainFriction);
BulletSimAPI.SetHitFraction2(m_mapInfo.terrainBody.ptr, BSParam.TerrainHitFraction);
BulletSimAPI.SetRestitution2(m_mapInfo.terrainBody.ptr, BSParam.TerrainRestitution);
BulletSimAPI.SetCollisionFlags2(m_mapInfo.terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
PhysicsScene.PE.SetFriction(m_mapInfo.terrainBody, BSParam.TerrainFriction);
PhysicsScene.PE.SetHitFraction(m_mapInfo.terrainBody, BSParam.TerrainHitFraction);
PhysicsScene.PE.SetRestitution(m_mapInfo.terrainBody, BSParam.TerrainRestitution);
PhysicsScene.PE.SetCollisionFlags(m_mapInfo.terrainBody, CollisionFlags.CF_STATIC_OBJECT);
// Return the new terrain to the world of physical objects
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_mapInfo.terrainBody);
// redo its bounding box now that it is in the world
BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr);
PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_mapInfo.terrainBody);
m_mapInfo.terrainBody.collisionType = CollisionType.Terrain;
m_mapInfo.terrainBody.ApplyCollisionMask();
// Make it so the terrain will not move or be considered for movement.
BulletSimAPI.ForceActivationState2(m_mapInfo.terrainBody.ptr, ActivationState.DISABLE_SIMULATION);
PhysicsScene.PE.ForceActivationState(m_mapInfo.terrainBody, ActivationState.DISABLE_SIMULATION);
return;
}
@ -136,10 +135,10 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
{
if (m_mapInfo.terrainBody.HasPhysicalBody)
{
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_mapInfo.terrainBody.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_mapInfo.terrainBody);
// Frees both the body and the shape.
PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_mapInfo.terrainBody);
BulletSimAPI.ReleaseHeightMapInfo2(m_mapInfo.Ptr);
PhysicsScene.PE.ReleaseHeightMapInfo(m_mapInfo.Ptr);
}
}
m_mapInfo = null;

13
OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
View File

@ -133,17 +133,14 @@ public sealed class BSTerrainManager : IDisposable
public void CreateInitialGroundPlaneAndTerrain()
{
// The ground plane is here to catch things that are trying to drop to negative infinity
BulletShape groundPlaneShape = new BulletShape(
BulletSimAPI.CreateGroundPlaneShape2(BSScene.GROUNDPLANE_ID, 1f,
BSParam.TerrainCollisionMargin),
BSPhysicsShapeType.SHAPE_GROUNDPLANE);
BulletShape groundPlaneShape = PhysicsScene.PE.CreateGroundPlaneShape(BSScene.GROUNDPLANE_ID, 1f, BSParam.TerrainCollisionMargin);
m_groundPlane = PhysicsScene.PE.CreateBodyWithDefaultMotionState(groundPlaneShape,
BSScene.GROUNDPLANE_ID, Vector3.Zero, Quaternion.Identity);
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr);
BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_groundPlane.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_groundPlane);
PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_groundPlane);
// Ground plane does not move
BulletSimAPI.ForceActivationState2(m_groundPlane.ptr, ActivationState.DISABLE_SIMULATION);
PhysicsScene.PE.ForceActivationState(m_groundPlane, ActivationState.DISABLE_SIMULATION);
// Everything collides with the ground plane.
m_groundPlane.collisionType = CollisionType.Groundplane;
m_groundPlane.ApplyCollisionMask();
@ -158,7 +155,7 @@ public sealed class BSTerrainManager : IDisposable
{
if (m_groundPlane.HasPhysicalBody)
{
if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr))
if (PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_groundPlane))
{
PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_groundPlane);
}

16
OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
View File

@ -114,32 +114,32 @@ public sealed class BSTerrainMesh : BSTerrainPhys
}
// Set current terrain attributes
BulletSimAPI.SetFriction2(m_terrainBody.ptr, BSParam.TerrainFriction);
BulletSimAPI.SetHitFraction2(m_terrainBody.ptr, BSParam.TerrainHitFraction);
BulletSimAPI.SetRestitution2(m_terrainBody.ptr, BSParam.TerrainRestitution);
BulletSimAPI.SetCollisionFlags2(m_terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
PhysicsScene.PE.SetFriction(m_terrainBody, BSParam.TerrainFriction);
PhysicsScene.PE.SetHitFraction(m_terrainBody, BSParam.TerrainHitFraction);
PhysicsScene.PE.SetRestitution(m_terrainBody, BSParam.TerrainRestitution);
PhysicsScene.PE.SetCollisionFlags(m_terrainBody, CollisionFlags.CF_STATIC_OBJECT);
// Static objects are not very massive.
BulletSimAPI.SetMassProps2(m_terrainBody.ptr, 0f, Vector3.Zero);
// Put the new terrain to the world of physical objects
BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_terrainBody.ptr);
PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_terrainBody);
// Redo its bounding box now that it is in the world
BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_terrainBody.ptr);
PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_terrainBody);
m_terrainBody.collisionType = CollisionType.Terrain;
m_terrainBody.ApplyCollisionMask();
// Make it so the terrain will not move or be considered for movement.
BulletSimAPI.ForceActivationState2(m_terrainBody.ptr, ActivationState.DISABLE_SIMULATION);
PhysicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);
}
public override void Dispose()
{
if (m_terrainBody.HasPhysicalBody)
{
BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_terrainBody.ptr);
PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_terrainBody);
// Frees both the body and the shape.
PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_terrainBody);
}

8
OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
View File

@ -367,7 +367,6 @@ public abstract void ReleaseBodyInfo(IntPtr obj);
public abstract void DestroyObject(BulletWorld sim, BulletBody obj);
/*
// =====================================================================================
// Terrain creation and helper routines
public abstract IntPtr CreateHeightMapInfo(BulletWorld sim, uint id, Vector3 minCoords, Vector3 maxCoords,
@ -378,9 +377,9 @@ public abstract IntPtr FillHeightMapInfo(BulletWorld sim, IntPtr mapInfo, uint i
public abstract bool ReleaseHeightMapInfo(IntPtr heightMapInfo);
public abstract BulletBody CreateGroundPlaneShape(uint id, float height, float collisionMargin);
public abstract BulletShape CreateGroundPlaneShape(uint id, float height, float collisionMargin);
public abstract BulletBody CreateTerrainShape(IntPtr mapInfo);
public abstract BulletShape CreateTerrainShape(IntPtr mapInfo);
// =====================================================================================
// Constraint creation and helper routines
@ -460,7 +459,7 @@ public abstract bool IsStaticOrKinematicObject(BulletBody obj);
public abstract bool HasContactResponse(BulletBody obj);
public abstract void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletBody shape);
public abstract void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletShape shape);
public abstract BulletShape GetCollisionShape(BulletBody obj);
@ -526,6 +525,7 @@ public abstract IntPtr GetUserPointer(BulletBody obj);
public abstract void SetUserPointer(BulletBody obj, IntPtr val);
/*
// =====================================================================================
// btRigidBody entries
public abstract void ApplyGravity(BulletBody obj);