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;
}
public Physics()
{
// collision configuration contains default setup for memory, collision setup
collisionConf = new DefaultCollisionConfiguration();
dispatcher = new CollisionDispatcher(collisionConf);
broadphase = new DbvtBroadphase();
World = new DiscreteDynamicsWorld(dispatcher, broadphase, null, collisionConf);
World.Gravity = new Vector3(0, -10, 0);
// create the ground
CollisionShape groundShape = new BoxShape(50, 50, 50);
collisionShapes.Add(groundShape);
CollisionObject ground = LocalCreateRigidBody(0, Matrix4.CreateTranslation(0, -50, 0), groundShape);
ground.UserObject = "Ground";
// create a few dynamic rigidbodies
const float mass = 1.0f;
CollisionShape colShape = new BoxShape(1);
collisionShapes.Add(colShape);
Vector3 localInertia = colShape.CalculateLocalInertia(mass);
const float start_x = StartPosX - ArraySizeX / 2;
const float start_y = StartPosY;
const float start_z = StartPosZ - ArraySizeZ / 2;
int k, i, j;
for (k = 0; k < ArraySizeY; k++)
{
for (i = 0; i < ArraySizeX; i++)
{
for (j = 0; j < ArraySizeZ; j++)
{
Matrix4 startTransform = Matrix4.CreateTranslation(
new Vector3(
2 * i + start_x,
2 * k + start_y,
2 * j + start_z
)
);
// using motionstate is recommended, it provides interpolation capabilities
// and only synchronizes 'active' objects
DefaultMotionState myMotionState = new DefaultMotionState(startTransform);
RigidBodyConstructionInfo rbInfo =
new RigidBodyConstructionInfo(mass, myMotionState, colShape, localInertia);
RigidBody body = new RigidBody(rbInfo);
// make it drop from a height
body.Translate(new Vector3(0, 20, 0));
World.AddRigidBody(body);
}
}
}
}
static PhysicsHandler()
{
//CreateSchedulers();
//NextTaskScheduler();
//using (var collisionConfigurationInfo = new DefaultCollisionConstructionInfo
//{
// DefaultMaxPersistentManifoldPoolSize = 80000,
// DefaultMaxCollisionAlgorithmPoolSize = 80000
//})
//{
// _collisionConf = new DefaultCollisionConfiguration(collisionConfigurationInfo);
//};
//_dispatcher = new CollisionDispatcherMultiThreaded(_collisionConf);
//_broadphase = new DbvtBroadphase();
//_solverPool = new ConstraintSolverPoolMultiThreaded(MaxThreadCount);
//_parallelSolver = new SequentialImpulseConstraintSolverMultiThreaded();
//World = new DiscreteDynamicsWorldMultiThreaded(_dispatcher, _broadphase, _solverPool, _parallelSolver, _collisionConf);
//World.SolverInfo.SolverMode = SolverModes.Simd | SolverModes.UseWarmStarting;
// collision configuration contains default setup for memory, collision setup
_collisionConf = new DefaultCollisionConfiguration();
_dispatcher = new CollisionDispatcher(_collisionConf);
_broadphase = new DbvtBroadphase();
World = new DiscreteDynamicsWorld(_dispatcher, _broadphase, null, _collisionConf);
World.Gravity = -10.0f * Vector3.UnitY;
//// create the ground
//var groundShape = new BoxShape(5, 0.125f, 5);
//_collisionShapes.Add(groundShape);
//Collider ground = CreateStaticCollider(groundShape, Matrix.Identity);
//ground.Body.UserObject = "Ground";
//// create a few dynamic rigidbodies
//var colShape = new BoxShape(0.5f);
//_collisionShapes.Add(colShape);
//float mass = 1.0f;
//Vector3 localInertia = colShape.CalculateLocalInertia(mass);
//using (var rbInfo = new RigidBodyConstructionInfo(mass, null, colShape, localInertia))
//{
// // using motionstate is recommended, it provides interpolation capabilities
// // and only synchronizes 'active' objects
// rbInfo.MotionState = new DefaultMotionState(Matrix.Translation(new Vector3(0.0f, 3.0f, 0.0f)));
// var body = new RigidBody(rbInfo);
// body.UserIndex = 0;
// World.AddRigidBody(body);
// rbInfo.MotionState = new DefaultMotionState(Matrix.Translation(new Vector3(0.5f, 4.5f, 0.0f)));
// body = new RigidBody(rbInfo);
// body.UserIndex = 1;
// World.AddRigidBody(body);
// rbInfo.MotionState = new DefaultMotionState(Matrix.Translation(new Vector3(1.0f, 6.0f, 0.0f)));
// body = new RigidBody(rbInfo);
// body.UserIndex = 2;
// World.AddRigidBody(body);
//}
}
public Physics(SceneManager sceneMgr)
{
// collision configuration contains default setup for memory, collision setup
collisionConf = new DefaultCollisionConfiguration();
Dispatcher = new CollisionDispatcher(collisionConf);
Broadphase = new DbvtBroadphase();
World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, null, collisionConf);
World.Gravity = new Vector3(0, -10, 0);
// create the ground
CollisionShape groundShape = new BoxShape(50, 1, 50);
CollisionShapes.Add(groundShape);
CollisionObject ground = LocalCreateRigidBody(0, Matrix4.IDENTITY, groundShape);
ground.UserObject = "Ground";
// create a few dynamic rigidbodies
float mass = 1.0f;
CollisionShape colShape = new BoxShape(1);
CollisionShapes.Add(colShape);
Vector3 localInertia = colShape.CalculateLocalInertia(mass);
var rbInfo = new RigidBodyConstructionInfo(mass, null, colShape, localInertia);
float start_x = StartPosX - ArraySizeX / 2;
float start_y = StartPosY;
float start_z = StartPosZ - ArraySizeZ / 2;
int k, i, j;
for (k = 0; k < ArraySizeY; k++)
{
for (i = 0; i < ArraySizeX; i++)
{
for (j = 0; j < ArraySizeZ; j++)
{
Matrix4 startTransform = new Matrix4();
startTransform.MakeTrans(
new Vector3(
2 * i + start_x,
2 * k + start_y,
2 * j + start_z
)
);
// using motionstate is recommended, it provides interpolation capabilities
// and only synchronizes 'active' objects
int index = (k * ArraySizeX + i) * ArraySizeZ + j;
Entity box = sceneMgr.CreateEntity("Box" + index.ToString(), "box.mesh");
box.SetMaterialName("BoxMaterial/Active");
SceneNode boxNode = sceneMgr.RootSceneNode.CreateChildSceneNode("BoxNode" + index.ToString());
boxNode.AttachObject(box);
boxNode.Scale(new Vector3(2, 2, 2));
var mogreMotionState = new MogreMotionState(box, boxNode, startTransform);
rbInfo.MotionState = mogreMotionState;
RigidBody body = new RigidBody(rbInfo);
mogreMotionState.Body = body;
// make it drop from a height
body.Translate(new Vector3(0, 20, 0));
World.AddRigidBody(body);
}
}
}
rbInfo.Dispose();
}
public Physics()
{
// collision configuration contains default setup for memory, collision setup
collisionConf = new DefaultCollisionConfiguration();
dispatcher = new CollisionDispatcher(collisionConf);
broadphase = new DbvtBroadphase();
World = new DiscreteDynamicsWorld(dispatcher, broadphase, null, collisionConf);
// create the ground
var groundShape = new BoxShape(50, 50, 50);
collisionShapes.Add(groundShape);
CollisionObject ground = LocalCreateRigidBody(0, Matrix.Translation(0, -50, 0), groundShape);
ground.UserObject = "Ground";
// create a few dynamic rigidbodies
float mass = 1.0f;
var colShape = new BoxShape(1);
collisionShapes.Add(colShape);
var rbInfo = new RigidBodyConstructionInfo(mass, null, colShape);
rbInfo.LocalInertia = colShape.CalculateLocalInertia(mass);
float start_x = StartPosX - ArraySizeX / 2;
float start_y = StartPosY;
float start_z = StartPosZ - ArraySizeZ / 2;
for (int y = 0; y < ArraySizeY; y++)
{
for (int x = 0; x < ArraySizeX; x++)
{
for (int z = 0; z < ArraySizeZ; z++)
{
Matrix startTransform = Matrix.Translation(
new Vector3(
2 * x + start_x,
2 * y + start_y,
2 * z + start_z
)
);
// using motionstate is recommended, it provides interpolation capabilities
// and only synchronizes 'active' objects
rbInfo.MotionState = new DefaultMotionState(startTransform);
var body = new RigidBody(rbInfo);
// make it drop from a height
body.Translate(new Vector3(0, 20, 0));
World.AddRigidBody(body);
}
}
}
rbInfo.Dispose();
}
protected void OnInitializePhysics()
{
// collision configuration contains default setup for memory, collision setup
CollisionConf = new DefaultCollisionConfiguration();
Dispatcher = new CollisionDispatcher(CollisionConf);
Broadphase = new DbvtBroadphase();
World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, null, CollisionConf);
World.Gravity = new BulletSharp.Math.Vector3(0, -10, 0);
BoxShape groundShape = new BoxShape(10, 0.5f, 10);
CollisionShapes.Add(groundShape);
CollisionObject ground = LocalCreateRigidBody(0.0f, Matrix.Identity, groundShape, true);
ground.UserObject = "Ground";
BoxShape WallShape1 = new BoxShape(0.5f, 25, 10);
CollisionShapes.Add(WallShape1);
CollisionObject wall1 = LocalCreateRigidBody(0.0f, Matrix.Translation(new BulletSharp.Math.Vector3(-10, 25, 0)), WallShape1, true);
wall1.UserObject = "Ground";
CollisionShapes.Add(WallShape1);
CollisionObject wall2 = LocalCreateRigidBody(0.0f, Matrix.Translation(new BulletSharp.Math.Vector3(10, 25, 0)), WallShape1, true);
wall2.UserObject = "Ground";
BoxShape WallShape2 = new BoxShape(10, 25, 0.5f);
CollisionShapes.Add(WallShape2);
CollisionObject wall3 = LocalCreateRigidBody(0.0f, Matrix.Translation(new BulletSharp.Math.Vector3(0, 25, -10)), WallShape2, true);
wall3.UserObject = "Ground";
CollisionShapes.Add(WallShape2);
CollisionObject wall4 = LocalCreateRigidBody(0.0f, Matrix.Translation(new BulletSharp.Math.Vector3(0, 25, 10)), WallShape2, true);
wall4.UserObject = "Ground";
float cubeSize = 0.5f;
float spacing = cubeSize;
float mass = 1.0f;
int size = 8;
BulletSharp.Math.Vector3 pos = new BulletSharp.Math.Vector3(0.0f, 20, 0.0f);
float offset = -size / 2 + 0.5f;
// 3000
BoxShape blockShape = new BoxShape(cubeSize);
mass = 2.0f;
for (int k = 0; k < MaxHeight; k++)
{
for (int j = 0; j < size; j++)
{
pos[2] = offset + j * (cubeSize * 2.0f);
for (int i = 0; i < size; i++)
{
pos[0] = offset + i * (cubeSize * 2.0f);
/*RigidBody cmbody =*/
LocalCreateRigidBody(mass, Matrix.Translation(pos), blockShape);
}
}
pos[1] += (cubeSize + spacing) * 2.0f;
}
}
protected void Dispose(bool disposing)
{
if (debugType >= BDebug.DebugType.Debug)
{
Debug.Log("BDynamicsWorld Disposing physics.");
}
if (lateUpdateHelper != null)
{
lateUpdateHelper.m_ddWorld = null;
lateUpdateHelper.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}", _ddWorld.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();
}
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 (Solver != null)
{
Solver.Dispose();
Solver = null;
}
if (softBodyWorldInfo != null)
{
softBodyWorldInfo.Dispose();
softBodyWorldInfo = null;
}
_isDisposed = true;
singleton = null;
}
/*
* 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 SequentialImpulseConstraintSolver solver,
out SoftBodyWorldInfo softBodyWorldInfo)
{
bool success = true;
if (m_worldType == WorldType.SoftBodyAndRigidBody && m_collisionType == CollisionConfType.DefaultDynamicsWorldCollisionConf)
{
BDebug.LogError(debugType, "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)
{
world = new DiscreteDynamicsWorld(dispatcher, broadphase, null, collisionConfig);
}
else if (m_worldType == WorldType.MultiBodyWorld)
{
world = new MultiBodyDynamicsWorld(dispatcher, broadphase, null, collisionConfig);
}
else if (m_worldType == WorldType.SoftBodyAndRigidBody)
{
Solver = new SequentialImpulseConstraintSolver();
Solver.RandSeed = sequentialImpulseConstraintSolverRandomSeed;
m_world = new SoftRigidDynamicsWorld(Dispatcher, Broadphase, Solver, 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);
}
public void ExitPhysics()
{
if (m_inverseModel != null)
{
Debug.Log("Dispose inverse model " + m_inverseModel.NumBodies);
m_inverseModel.Dispose();
}
Debug.Log("InverseDynamicsExitPhysics");
//cleanup in the reverse order of creation/initialization
//remove the rigidbodies from the dynamics world and delete them
if (m_dynamicsWorld == null)
{
int i;
for (i = m_dynamicsWorld.NumConstraints - 1; i >= 0; i--)
{
TypedConstraint tc = m_dynamicsWorld.GetConstraint(i);
m_dynamicsWorld.RemoveConstraint(tc);
tc.Dispose();
}
for (i = m_dynamicsWorld.NumMultiBodyConstraints - 1; i >= 0; i--)
{
MultiBodyConstraint mbc = m_dynamicsWorld.GetMultiBodyConstraint(i);
m_dynamicsWorld.RemoveMultiBodyConstraint(mbc);
mbc.Dispose();
}
for (i = m_dynamicsWorld.NumMultibodies - 1; i >= 0; i--)
{
MultiBody mb = m_dynamicsWorld.GetMultiBody(i);
m_dynamicsWorld.RemoveMultiBody(mb);
mb.Dispose();
}
for (i = m_dynamicsWorld.NumCollisionObjects - 1; i >= 0; i--)
{
CollisionObject obj = m_dynamicsWorld.CollisionObjectArray[i];
RigidBody body = RigidBody.Upcast(obj);
if (body != null && body.MotionState != null)
{
body.MotionState.Dispose();
}
m_dynamicsWorld.RemoveCollisionObject(obj);
obj.Dispose();
}
}
if (m_multiBody != null)
{
m_multiBody.Dispose();
}
//delete collision shapes
for (int j = 0; j < CollisionShapes.Count; j++)
{
CollisionShape shape = CollisionShapes[j];
shape.Dispose();
}
CollisionShapes.Clear();
m_dynamicsWorld.Dispose();
m_dynamicsWorld = null;
m_solver.Dispose();
m_solver = null;
Broadphase.Dispose();
Broadphase = null;
Dispatcher.Dispose();
Dispatcher = null;
m_pairCache.Dispose();
m_pairCache = null;
CollisionConf.Dispose();
CollisionConf = null;
CollisionShapes.Clear();
links.Clear();
Debug.Log("After dispose B");
}