public SoftRigidDynamicsWorld(Dispatcher dispatcher, BroadphaseInterface pairCache,
ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration,
SoftBodySolver softBodySolver = null)
{
if (softBodySolver != null)
{
_softBodySolver = softBodySolver;
_ownsSolver = false;
}
else
{
_softBodySolver = new DefaultSoftBodySolver();
_ownsSolver = true;
}
IntPtr native = btSoftRigidDynamicsWorld_new(dispatcher.Native, pairCache.Native,
(constraintSolver != null) ? constraintSolver.Native : IntPtr.Zero,
collisionConfiguration.Native, _softBodySolver.Native);
InitializeUserOwned(native);
InitializeMembers(dispatcher, pairCache, constraintSolver);
WorldInfo = new SoftBodyWorldInfo(btSoftRigidDynamicsWorld_getWorldInfo(Native), this)
{
Dispatcher = dispatcher,
Broadphase = pairCache
};
}
public void Initialize()
{
if (World != null) // check if we are already initialized
{
return;
}
enabled = true;
CollisionConf = new DefaultCollisionConfiguration();
Dispatcher = new CollisionDispatcher(CollisionConf);
// Select Brodphase
Broadphase = new DbvtBroadphase();
//Broadphase = new AxisSweep3(new Vector3(-1000.0f, -1000.0f, -30.0f), new Vector3(2000.0f, 3000.0f, 1000.0f), 32766);
DantzigSolver dtsolver = new DantzigSolver();
Solver = new MlcpSolver(dtsolver);
//Create a collision world of your choice, for now pass null as the constraint solver
World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf);
var si = World.SolverInfo;
si.NumIterations = 2;
si.TimeStep = 0.001f;
World.SetGravity(ref _gravityVec);
ghostPairCallback = new GhostPairCallback();
World.PairCache.SetInternalGhostPairCallback(ghostPairCallback);
}
public SoftRigidDynamicsWorld(Dispatcher dispatcher, BroadphaseInterface pairCache,
ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration,
SoftBodySolver softBodySolver)
: base(IntPtr.Zero)
{
if (softBodySolver != null) {
_softBodySolver = softBodySolver;
_ownsSolver = false;
} else {
_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);
_broadphase = pairCache;
_constraintSolver = constraintSolver;
_dispatcher = dispatcher;
_worldInfo = new SoftBodyWorldInfo(btSoftRigidDynamicsWorld_getWorldInfo(_native), true);
_worldInfo.Dispatcher = dispatcher;
_worldInfo.Broadphase = pairCache;
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
public static void Start()
{
var random = new Random(0);
var box = new Interval3d(new Vec3d(0.0), new Vec3d(10.0)); // create a interval between the (0,0,0) and (10,10,10)
// create particles
var particles = new Particle[] {
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box)),
new Particle(random.NextVec3d(box))
};
// create constraints
var constraints = new IConstraint[] {
new PlanarQuad(0, 1, 2, 3)
};
// create solver
var solver = new ConstraintSolver();
// wait for keypress to start the solver
Console.WriteLine("Press return to start the solver.");
Console.ReadLine();
// step the solver until converged
while (!solver.IsConverged)
{
solver.Step(particles, constraints);
Console.WriteLine($" step {solver.StepCount}");
}
Console.WriteLine("\nSolver converged! Press return to exit.");
Console.ReadLine();
}
internal DynamicWorldImp()
{
//Debug.WriteLine("DynamicWorldImp");
//Default
// collision configuration contains default setup for memory, collision setup
BtCollisionConf = new DefaultCollisionConfiguration();
BtDispatcher = new CollisionDispatcher(BtCollisionConf);
BtBroadphase = new DbvtBroadphase();
BtSolver = new SequentialImpulseConstraintSolver();
// BtCollisionShapes = new AlignedCollisionShapeArray();
BtWorld = new DiscreteDynamicsWorld(BtDispatcher, BtBroadphase, BtSolver, BtCollisionConf)
{
Gravity = new Vector3(0, -9.81f, 0)
};
BtWorld.SolverInfo.NumIterations = 5;
BtWorld.PerformDiscreteCollisionDetection();
//GImpactCollisionAlgorithm.RegisterAlgorithm(BtDispatcher);
// BtWorld.SetInternalTickCallback(MyTickCallBack);
//BtWorld.SetInternalTickCallback(TickTack);
//ManifoldPoint.ContactAdded += OnContactAdded;
//PersistentManifold.ContactDestroyed += OnContactDestroyed;
//PersistentManifold.ContactProcessed += OnContactProcessed;
}
public SoftRigidDynamicsWorld(Dispatcher dispatcher, BroadphaseInterface pairCache, ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration, SoftBodySolver softBodySolver)
: base(IntPtr.Zero)
{
if (softBodySolver != null)
{
_softBodySolver = softBodySolver;
_ownsSolver = false;
}
else
{
_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);
_dispatcher = dispatcher;
_broadphase = pairCache;
_constraintSolver = constraintSolver;
_worldInfo = new SoftBodyWorldInfo(btSoftRigidDynamicsWorld_getWorldInfo(_native), true);
_worldInfo.Dispatcher = dispatcher;
_worldInfo.Broadphase = pairCache;
_native2ManagedMap.Add(_native, this);
}
private void UpdateConstraints()
{
// Method name explains it all.
for (int i = 0; i < 1; i++)
{
ConstraintSolver.Update(_myVerlets, _myVerlets[0].TimeStep);
}
}
private void SolveIsland(int i)
{
var island = IslandManager.IslandsInternal[i];
if (!island.IsSleeping())
{
// Constraint handling.
ConstraintSolver.Solve(island, _fixedTimeStep);
}
}
public static ConstraintSolver Instance()
{
if (instance == null)
{
instance = new ConstraintSolver();
}
return(instance);
}
public void Unexecute()
{
ConstraintSolver solver = ConstraintSolver.Instance();
this.target.Move(this.delta);
solver.SetMemento(this.state); // restore solver state
solver.Solve();
}
public void Execute()
{
ConstraintSolver solver = ConstraintSolver.Instance();
this.state = solver.CreateMemento(); // create a memento
this.target.Move(this.delta);
solver.Solve();
}
void StartUp()
{
m_collisionConfiguration = new ErdeCollisionConfiguration();
m_collisionDispatcher = new CollisionDispatcher(m_collisionConfiguration);
m_broadphaseInterface = new DbvtBroadphase();
m_constraintSolver = new SequentialmpulseConstraintSolver();
m_world = new DiscreteDynamicsWorld(m_collisionDispatcher, m_broadphaseInterface, m_constraintSolver, m_collisionConfiguration);
m_world.Gravity = new Vector3(0.0f, -9.87f, 0.0f);
}
public BulletPhysicWorld(Vector3 gravity)
{
collisionConf = new DefaultCollisionConfiguration();
Dispatcher = new CollisionDispatcher(collisionConf);
Broadphase = new DbvtBroadphase();
constraintSolver = new SequentialImpulseConstraintSolver();
objs = new List <IPhysicObject>();
ctns = new List <IPhysicConstraint>();
world = new DiscreteDynamicsWorld(Dispatcher, Broadphase, constraintSolver, collisionConf);
world.Gravity = gravity;
}
internal static void Init()
{
collisionConf = new DefaultCollisionConfiguration();
dispatcher = new CollisionDispatcher(collisionConf);
broadphase = new DbvtBroadphase();
solver = new SequentialImpulseConstraintSolver();
world = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConf);
//filterCB = new CollisionFilterCallback();
//world.PairCache.SetOverlapFilterCallback(filterCB);
initialized = true;
}
/// <summary>
/// gRally
/// </summary>
/// <param name="worldCreated"></param>
/// <param name="dispatcher"></param>
/// <param name="pairCache"></param>
/// <param name="constraintSolver"></param>
public SoftRigidDynamicsWorld(IntPtr worldCreated, Dispatcher dispatcher, BroadphaseInterface pairCache, ConstraintSolver constraintSolver)
: base(IntPtr.Zero)
{
_softBodySolver = new DefaultSoftBodySolver();
_ownsSolver = true;
_native = worldCreated;
_collisionObjectArray = new AlignedCollisionObjectArray(btCollisionWorld_getCollisionObjectArray(_native), this);
_dispatcher = dispatcher;
_broadphase = pairCache;
_constraintSolver = constraintSolver;
_worldInfo = new SoftBodyWorldInfo(btSoftRigidDynamicsWorld_getWorldInfo(_native), true);
_worldInfo.Dispatcher = dispatcher;
_worldInfo.Broadphase = pairCache;
_native2ManagedMap.Add(_native, this);
}
public void Dispose(bool disposing)
{
if (_isDisposed)
{
return;
}
if (disposing)
{
// Dispose managed resources.
}
// All bullet rosources are unmanaged.
if (World != null)
{
World.Dispose();
World = null;
}
if (Broadphase != null)
{
Broadphase.Dispose();
Broadphase = null;
}
if (Dispatcher != null)
{
Dispatcher.Dispose();
Dispatcher = null;
}
if (CollisionConf != null)
{
CollisionConf.Dispose();
CollisionConf = null;
}
if (Solver != null)
{
Solver.Dispose();
Solver = null;
}
_isDisposed = true;
}
/// <summary>
///
/// </summary>
public static void Start()
{
// import halfedge mesh
var mesh = HeMesh3d.Factory.CreateFromOBJ(Paths.Resources + _fileIn);
// create particles
var bodies = mesh.Vertices.Select(v => new Body(v.Position)).ToArray();
// create constraints
var constraints = mesh.Faces.Where(f => !f.IsDegree3)
.Select(f => new Coplanar(f.Vertices.Select(v => v.Index)))
.ToArray();
// create solver
var solver = new ConstraintSolver();
solver.Settings.LinearDamping = 0.1;
// wait for keypress to start the solver
Console.WriteLine("Press return to start the solver.");
Console.ReadLine();
// step the solver until converged
while (!solver.IsConverged)
{
solver.Step(bodies, constraints, true);
Console.WriteLine($" step {solver.StepCount}");
}
Console.WriteLine("\nSolver converged! Press return to exit.");
// update mesh vertices
mesh.Vertices.Action(v => v.Position = bodies[v].Position.Current); // mesh elements (vertices, halfedges, faces) are implicitly converted to their index
// compute vertex normals & write to file
mesh.Vertices.Action(v => v.Normal = v.GetNormal(), true);
Interop.Meshes.WriteToObj(mesh, Paths.Resources + _fileOut);
Console.ReadLine();
}
public void InitPhysics()
{
CollisionConf = new DefaultCollisionConfiguration();
Dispatcher = new CollisionDispatcher(CollisionConf);
Broadphase = new DbvtBroadphase();
Broadphase.OverlappingPairCache.SetInternalGhostPairCallback(new GhostPairCallback());
Solver = new SequentialImpulseConstraintSolver();
World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, Solver, CollisionConf);
World.SolverInfo.SolverMode |= SolverModes.Use2FrictionDirections | SolverModes.RandomizeOrder;
World.SolverInfo.NumIterations = 20;
World.DispatchInfo.AllowedCcdPenetration = 0.0001f;
World.DispatchInfo.UseContinuous = true;
World.Gravity = new Vector3(0, -600, 0);
ClosestConvexResult = new ClosestConvexResultCallback();
EntPhysics MapPhysics = new EntPhysics(libTechCollisionShape.FromVerticesConcave(GetModels().First().GetMeshes().SelectMany(M => M.GetVertices().Select(V => V.Position))), 0);
SpawnEntity(MapPhysics);
}
/// <summary>
///
/// </summary>
public static void Run()
{
// import halfedge mesh
var mesh = HeMesh3d.Factory.CreateFromOBJ(Paths.Resources + _fileIn);
// create particles
var particles = mesh.Vertices.Select(v => new Particle(v.Position)).ToArray();
// create constraints
var constraints = mesh.Faces.Where(f => !f.IsDegree3)
.Select(f => new PlanarNgon(f.Vertices.Select(v => v.Index)))
.ToArray();
// create solver
var solver = new ConstraintSolver();
// wait for keypress to start the solver
Console.WriteLine("Press return to start the solver.");
Console.ReadLine();
// step the solver until converged
while (!solver.IsConverged)
{
solver.StepParallel(particles, constraints);
Console.WriteLine($" step {solver.StepCount}");
}
Console.WriteLine("\nSolver converged! Press return to exit.");
// update mesh vertices
mesh.Vertices.Action(v => v.Position = particles[v.Index].Position);
// mesh.Vertices.Action(v => v.Position = particles[v].Position); // mesh elements (vertices, halfedges, faces) are converted to their indices implicitly so this also works
// compute vertex normals & write to file
mesh.GetVertexNormals(v => v.Position, (v, n) => v.Normal = n, true);
mesh.WriteToOBJ(Paths.Resources + _fileOut);
Console.ReadLine();
}
public DiscreteDynamicsWorld(CollisionDispatcher a_dispatcher, BroadphaseInterface a_broadphase, ConstraintSolver a_solver, CollisionConfiguration a_configuration)
{
m_objectPtr = DiscreteDynamicsWorld_new(a_dispatcher.Ptr, a_broadphase.Ptr, a_solver.Ptr, a_configuration.Ptr);
m_debugDrawerPtr = IntPtr.Zero;
m_drawLineEvent = DrawLine;
m_errorEvent = Error;
m_collisionEvent = OnCollision;
m_objectLookup = new Dictionary <IntPtr, CollisionObject>();
}
protected void Dispose(bool disposing)
{
if (lateUpdateHelper != null)
{
lateUpdateHelper.m_ddWorld = null;
lateUpdateHelper.m_world = null;
}
if (m_world != null)
{
//remove/dispose constraints
int i;
if (_ddWorld != null)
{
for (i = _ddWorld.NumConstraints - 1; i >= 0; i--)
{
TypedConstraint constraint = _ddWorld.GetConstraint(i);
_ddWorld.RemoveConstraint(constraint);
if (constraint.Userobject is BTypedConstraint)
{
((BTypedConstraint)constraint.Userobject).m_isInWorld = false;
}
constraint.Dispose();
}
}
//remove the rigidbodies from the dynamics world and delete them
for (i = m_world.NumCollisionObjects - 1; i >= 0; i--)
{
CollisionObject obj = m_world.CollisionObjectArray[i];
RigidBody body = obj as RigidBody;
if (body != null && body.MotionState != null)
{
Debug.Assert(body.NumConstraintRefs == 0, "Rigid body still had constraints");
body.MotionState.Dispose();
}
m_world.RemoveCollisionObject(obj);
if (obj.UserObject is BCollisionObject)
{
((BCollisionObject)obj.UserObject).isInWorld = false;
}
obj.Dispose();
}
if (m_world.DebugDrawer != null)
{
if (m_world.DebugDrawer is IDisposable)
{
IDisposable dis = (IDisposable)m_world.DebugDrawer;
dis.Dispose();
}
}
m_world.Dispose();
Broadphase.Dispose();
Dispatcher.Dispose();
CollisionConf.Dispose();
_ddWorld = null;
m_world = null;
}
if (Broadphase != null)
{
Broadphase.Dispose();
Broadphase = null;
}
if (Dispatcher != null)
{
Dispatcher.Dispose();
Dispatcher = null;
}
if (CollisionConf != null)
{
CollisionConf.Dispose();
CollisionConf = null;
}
if (constraintSolver != null)
{
constraintSolver.Dispose();
constraintSolver = null;
}
if (softBodyWorldInfo != null)
{
softBodyWorldInfo.Dispose();
softBodyWorldInfo = null;
}
_isDisposed = true;
singleton = null;
}
public void SetConstraint(Verlet v)
{
ConstraintSolver.Set(Index, v.Index, CurrentPosition, v.CurrentPosition);
}
//Does not set any local variables. Is safe to use to create duplicate physics worlds for independant simulation.
public void CreatePhysicsWorld
(
out CollisionWorld world,
out CollisionConfiguration collisionConfig,
out CollisionDispatcher dispatcher,
out BroadphaseInterface broadphase,
out ConstraintSolver solver,
out SoftBodyWorldInfo softBodyWorldInfo
)
{
collisionConfig = null;
switch (physicWorldParameters.collisionType)
{
default:
case CollisionConfType.DefaultDynamicsWorldCollisionConf:
collisionConfig = new DefaultCollisionConfiguration();
break;
case CollisionConfType.SoftBodyRigidBodyCollisionConf:
collisionConfig = new SoftBodyRigidBodyCollisionConfiguration();
break;
}
dispatcher = new CollisionDispatcher(collisionConfig);
switch (physicWorldParameters.broadphaseType)
{
default:
case BroadphaseType.DynamicAABBBroadphase:
broadphase = new DbvtBroadphase();
break;
case BroadphaseType.Axis3SweepBroadphase:
broadphase = new AxisSweep3(
physicWorldParameters.axis3SweepBroadphaseMin,
physicWorldParameters.axis3SweepBroadphaseMax,
physicWorldParameters.axis3SweepMaxProxies
);
break;
case BroadphaseType.Axis3SweepBroadphase_32bit:
broadphase = new AxisSweep3_32Bit(
physicWorldParameters.axis3SweepBroadphaseMin,
physicWorldParameters.axis3SweepBroadphaseMax,
physicWorldParameters.axis3SweepMaxProxies
);
break;
}
world = null;
softBodyWorldInfo = null;
solver = null;
switch (physicWorldParameters.worldType)
{
case WorldType.CollisionOnly:
world = new CollisionWorld(dispatcher, broadphase, collisionConfig);
break;
default:
case WorldType.RigidBodyDynamics:
world = new DiscreteDynamicsWorld(dispatcher, broadphase, null, collisionConfig);
break;
case WorldType.MultiBodyWorld:
MultiBodyConstraintSolver mbConstraintSolver = new MultiBodyConstraintSolver();
constraintSolver = mbConstraintSolver;
world = new MultiBodyDynamicsWorld(dispatcher, broadphase, mbConstraintSolver, collisionConfig);
break;
case WorldType.SoftBodyAndRigidBody:
SequentialImpulseConstraintSolver siConstraintSolver = new SequentialImpulseConstraintSolver();
constraintSolver = siConstraintSolver;
siConstraintSolver.RandSeed = physicWorldParameters.sequentialImpulseConstraintSolverRandomSeed;
world = new SoftRigidDynamicsWorld(this.dispatcher, this.broadphase, siConstraintSolver, collisionConf);
world.DispatchInfo.EnableSpu = true;
SoftRigidDynamicsWorld _sworld = (SoftRigidDynamicsWorld)world;
_sworld.WorldInfo.SparseSdf.Initialize();
_sworld.WorldInfo.SparseSdf.Reset();
_sworld.WorldInfo.AirDensity = 1.2f;
_sworld.WorldInfo.WaterDensity = 0;
_sworld.WorldInfo.WaterOffset = 0;
_sworld.WorldInfo.WaterNormal = BulletSharp.Math.Vector3.Zero;
_sworld.WorldInfo.Gravity = Gravity.ToBullet();
break;
}
if (world is DiscreteDynamicsWorld)
{
((DiscreteDynamicsWorld)world).Gravity = Gravity.ToBullet();
}
}
public BulletPhysicWorld(Vector3 gravity, Dispatcher dispatcher, BroadphaseInterface pairCache, ConstraintSolver constraintSolver, CollisionConfiguration collisionConfiguration)
{
objs = new List <IPhysicObject>();
ctns = new List <IPhysicConstraint>();
world = new DiscreteDynamicsWorld(dispatcher, pairCache, constraintSolver, collisionConfiguration);
world.Gravity = gravity;
}
/*
* Does not set any local variables. Is safe to use to create duplicate physics worlds for independant simulation.
*/
public bool CreatePhysicsWorld(out CollisionWorld world,
out CollisionConfiguration collisionConfig,
out CollisionDispatcher dispatcher,
out BroadphaseInterface broadphase,
out ConstraintSolver solver,
out SoftBodyWorldInfo softBodyWorldInfo)
{
bool success = true;
if (m_worldType == WorldType.SoftBodyAndRigidBody && m_collisionType == CollisionConfType.DefaultDynamicsWorldCollisionConf)
{
Debug.LogError("For World Type = SoftBodyAndRigidBody collisionType must be collisionType=SoftBodyRigidBodyCollisionConf. Switching");
m_collisionType = CollisionConfType.SoftBodyRigidBodyCollisionConf;
success = false;
}
collisionConfig = null;
if (m_collisionType == CollisionConfType.DefaultDynamicsWorldCollisionConf)
{
collisionConfig = new DefaultCollisionConfiguration();
}
else if (m_collisionType == CollisionConfType.SoftBodyRigidBodyCollisionConf)
{
collisionConfig = new SoftBodyRigidBodyCollisionConfiguration();
}
dispatcher = new CollisionDispatcher(collisionConfig);
if (m_broadphaseType == BroadphaseType.DynamicAABBBroadphase)
{
broadphase = new DbvtBroadphase();
}
else if (m_broadphaseType == BroadphaseType.Axis3SweepBroadphase)
{
broadphase = new AxisSweep3(m_axis3SweepBroadphaseMin.ToBullet(), m_axis3SweepBroadphaseMax.ToBullet(), axis3SweepMaxProxies);
}
else if (m_broadphaseType == BroadphaseType.Axis3SweepBroadphase_32bit)
{
broadphase = new AxisSweep3_32Bit(m_axis3SweepBroadphaseMin.ToBullet(), m_axis3SweepBroadphaseMax.ToBullet(), axis3SweepMaxProxies);
}
else
{
broadphase = null;
}
world = null;
softBodyWorldInfo = null;
solver = null;
if (m_worldType == WorldType.CollisionOnly)
{
world = new CollisionWorld(dispatcher, broadphase, collisionConfig);
}
else if (m_worldType == WorldType.RigidBodyDynamics)
{
switch (solverType)
{
case SolverType.MLCP:
DantzigSolver dtsolver = new DantzigSolver();
solver = new MlcpSolver(dtsolver);
break;
default:
break;
}
world = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfig);
}
else if (m_worldType == WorldType.MultiBodyWorld)
{
MultiBodyConstraintSolver mbConstraintSolver = null;
switch (solverType)
{
/* case SolverType.MLCP:
* DantzigSolver dtsolver = new DantzigSolver();
* mbConstraintSolver = new MultiBodyMLCPConstraintSolver(dtsolver);
* break;*/
default:
mbConstraintSolver = new MultiBodyConstraintSolver();
break;
}
world = new MultiBodyDynamicsWorld(dispatcher, broadphase, mbConstraintSolver, collisionConfig);
}
else if (m_worldType == WorldType.SoftBodyAndRigidBody)
{
SequentialImpulseConstraintSolver siConstraintSolver = new SequentialImpulseConstraintSolver();
constraintSolver = siConstraintSolver;
siConstraintSolver.RandSeed = sequentialImpulseConstraintSolverRandomSeed;
m_world = new SoftRigidDynamicsWorld(Dispatcher, Broadphase, siConstraintSolver, CollisionConf);
_ddWorld = (DiscreteDynamicsWorld)m_world;;
SoftRigidDynamicsWorld _sworld = (SoftRigidDynamicsWorld)m_world;
m_world.DispatchInfo.EnableSpu = true;
_sworld.WorldInfo.SparseSdf.Initialize();
_sworld.WorldInfo.SparseSdf.Reset();
_sworld.WorldInfo.AirDensity = 1.2f;
_sworld.WorldInfo.WaterDensity = 0;
_sworld.WorldInfo.WaterOffset = 0;
_sworld.WorldInfo.WaterNormal = BulletSharp.Math.Vector3.Zero;
_sworld.WorldInfo.Gravity = m_gravity.ToBullet();
}
if (world is DiscreteDynamicsWorld)
{
((DiscreteDynamicsWorld)world).Gravity = m_gravity.ToBullet();
}
if (_doDebugDraw)
{
DebugDrawUnity db = new DebugDrawUnity();
db.DebugMode = _debugDrawMode;
world.DebugDrawer = db;
}
return(success);
}
protected void Dispose(bool disposing)
{
if (debugType >= BDebug.DebugType.Debug)
{
Debug.Log("BDynamicsWorld Disposing physics.");
}
if (PhysicsWorldHelper != null)
{
PhysicsWorldHelper.m_ddWorld = null;
PhysicsWorldHelper.m_world = null;
}
if (m_world != null)
{
//remove/dispose constraints
int i;
if (_ddWorld != null)
{
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removing Constraints {0}", _ddWorld.NumConstraints);
}
for (i = _ddWorld.NumConstraints - 1; i >= 0; i--)
{
TypedConstraint constraint = _ddWorld.GetConstraint(i);
_ddWorld.RemoveConstraint(constraint);
if (constraint.Userobject is BTypedConstraint)
{
((BTypedConstraint)constraint.Userobject).m_isInWorld = false;
}
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removed Constaint {0}", constraint.Userobject);
}
constraint.Dispose();
}
}
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removing Collision Objects {0}", m_world.NumCollisionObjects);
}
//remove the rigidbodies from the dynamics world and delete them
for (i = m_world.NumCollisionObjects - 1; i >= 0; i--)
{
CollisionObject obj = m_world.CollisionObjectArray[i];
RigidBody body = obj as RigidBody;
if (body != null && body.MotionState != null)
{
Debug.Assert(body.NumConstraintRefs == 0, "Rigid body still had constraints");
body.MotionState.Dispose();
}
m_world.RemoveCollisionObject(obj);
if (obj.UserObject is BCollisionObject)
{
((BCollisionObject)obj.UserObject).isInWorld = false;
}
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removed CollisionObject {0}", obj.UserObject);
}
obj.Dispose();
}
MultiBodyDynamicsWorld _mbdWorld = m_world as MultiBodyDynamicsWorld;
if (_mbdWorld != null)
{
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removing MultiBody Constraints {0}", _mbdWorld.NumMultiBodyConstraints);
}
for (i = _mbdWorld.NumMultiBodyConstraints - 1; i >= 0; i--)
{
MultiBodyConstraint constraint = _mbdWorld.GetMultiBodyConstraint(i);
_mbdWorld.RemoveMultiBodyConstraint(constraint);
/* if (constraint.Userobject is BTypedConstraint) ((BTypedConstraint)constraint.Userobject).m_isInWorld = false;
* if (debugType >= BDebug.DebugType.Debug) Debug.LogFormat("Removed Constaint {0}", constraint.Userobject);*/
constraint.Dispose();
}
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removing Multibodies {0}", _mbdWorld.NumMultibodies);
}
//remove the rigidbodies from the dynamics world and delete them
for (i = _mbdWorld.NumMultibodies - 1; i >= 0; i--)
{
MultiBody mb = _mbdWorld.GetMultiBody(i);
_mbdWorld.RemoveMultiBody(mb);
if (mb.UserObject is BMultiBody bmb)
{
bmb.isInWorld = false;
}
if (debugType >= BDebug.DebugType.Debug)
{
Debug.LogFormat("Removed CollisionObject {0}", mb.UserObject);
}
mb.Dispose();
}
}
if (m_world.DebugDrawer != null)
{
if (m_world.DebugDrawer is IDisposable)
{
IDisposable dis = (IDisposable)m_world.DebugDrawer;
dis.Dispose();
}
}
m_world.Dispose();
Broadphase.Dispose();
Dispatcher.Dispose();
CollisionConf.Dispose();
_ddWorld = null;
m_world = null;
}
if (Broadphase != null)
{
Broadphase.Dispose();
Broadphase = null;
}
if (Dispatcher != null)
{
Dispatcher.Dispose();
Dispatcher = null;
}
if (CollisionConf != null)
{
CollisionConf.Dispose();
CollisionConf = null;
}
if (constraintSolver != null)
{
constraintSolver.Dispose();
constraintSolver = null;
}
if (softBodyWorldInfo != null)
{
softBodyWorldInfo.Dispose();
softBodyWorldInfo = null;
}
_isDisposed = true;
singleton = null;
}
//Initialize the physics world
private void InitializeWorld(DynamicsWorld.InternalTickCallback tickCallBack)
{
//Collision configuration and dispatcher
var collisionConfigInfo = new DefaultCollisionConstructionInfo {
DefaultMaxCollisionAlgorithmPoolSize = 80000,
DefaultMaxPersistentManifoldPoolSize = 80000
};
_collisionConfig = new DefaultCollisionConfiguration(collisionConfigInfo);
//Solver Type Config
switch (_solverType)
{
case WorldSolverType.SequentialImpulse:
_constraintSolver = new MultiBodyConstraintSolver();
_collisionDispatcher = new CollisionDispatcher(_collisionConfig);
break;
case WorldSolverType.NonSmoothNonLinearConjugate:
_constraintSolver = new NncgConstraintSolver();
_collisionDispatcher = new CollisionDispatcher(_collisionConfig);
break;
case WorldSolverType.ExperimentalMultiThreaded: //EXPERIMENTAL
switch (_schedulerType)
{
case TaskSchedulerType.Sequential:
Threads.TaskScheduler = Threads.GetSequentialTaskScheduler();
break;
case TaskSchedulerType.OpenMp:
Threads.TaskScheduler = Threads.GetOpenMPTaskScheduler();
break;
case TaskSchedulerType.Ppl:
Threads.TaskScheduler = Threads.GetPplTaskScheduler();
break;
default:
throw new ArgumentOutOfRangeException();
}
_threadedSolver = new ConstraintSolverPoolMultiThreaded(_solverThreads);
Threads.TaskScheduler.NumThreads = _threadPoolSize;
_collisionDispatcher = new CollisionDispatcherMultiThreaded(_collisionConfig);
break;
default:
throw new ArgumentOutOfRangeException();
}
//Broadphase Type COnfig
switch (_broadphaseType)
{
case WorldBroadphaseType.DynamicAabb:
_broadphaseInterface = new DbvtBroadphase();
break;
case WorldBroadphaseType.AxisSweep:
_broadphaseInterface = new AxisSweep3(-_axisSweepMargin.ToBullet(), _axisSweepMargin.ToBullet());
break;
default:
throw new ArgumentOutOfRangeException();
}
//Create the physics world
if (_solverType == WorldSolverType.ExperimentalMultiThreaded)
{
_dynamicsWorld = new DiscreteDynamicsWorldMultiThreaded(_collisionDispatcher, _broadphaseInterface, _threadedSolver, _collisionConfig);
}
else
{
_dynamicsWorld = new DiscreteDynamicsWorld(_collisionDispatcher, _broadphaseInterface, _constraintSolver, _collisionConfig);
}
//Configure the physics world
_dynamicsWorld.SolverInfo.NumIterations = _solverIterations;
_dynamicsWorld.SolverInfo.SolverMode = SolverModes.Simd | SolverModes.UseWarmStarting;
_dynamicsWorld.SetInternalTickCallback(tickCallBack);
_btGravity = _gravity.ToBullet();
_dynamicsWorld.SetGravity(ref _btGravity);
_initlialized = true;
if (_debugging)
{
Debug.Log("<b>Bullet4Unity:</b> Initialized Bullet Physics World");
}
}
