public void AddBody(ICollider iCollider)
{
if (!(iCollider is TSCollider2D))
{
Debug.LogError("You have a 3D object but your Physics 3D is disabled.");
return;
}
TSCollider2D tsCollider = (TSCollider2D)iCollider;
if (tsCollider._body != null)
{
//already added
return;
}
tsCollider.Initialize(world);
gameObjectMap[tsCollider._body] = tsCollider.gameObject;
if (tsCollider.gameObject.transform.parent != null && tsCollider.gameObject.transform.parent.GetComponentInParent <TSCollider2D>() != null)
{
TSCollider2D parentCollider = tsCollider.gameObject.transform.parent.GetComponentInParent <TSCollider2D>();
Physics2D.Body childBody = tsCollider._body;
childBody.bodyConstraints.Add(new ConstraintHierarchy2D(((Physics2D.Body)parentCollider.Body), tsCollider._body, (tsCollider.GetComponent <TSTransform2D>().position + tsCollider.ScaledCenter) - (parentCollider.GetComponent <TSTransform2D>().position + parentCollider.ScaledCenter)));
}
world.ProcessAddedBodies();
}
private TSCollision2D GetCollisionInfo(Physics2D.Body body1, Physics2D.Body body2, SyncFrame.Physics2D.Contact c)
{
if (!collisionInfo.ContainsKey(body1))
{
collisionInfo.Add(body1, new Dictionary <Physics2D.Body, TSCollision2D>());
}
Dictionary <Physics2D.Body, TSCollision2D> collisionInfoBody1 = collisionInfo[body1];
TSCollision2D result = null;
if (collisionInfoBody1.ContainsKey(body2))
{
result = collisionInfoBody1[body2];
}
else
{
result = new TSCollision2D();
collisionInfoBody1.Add(body2, result);
}
result.Update(gameObjectMap[body2], c);
return(result);
}
private void CreateBodyFixture(Physics2D.Body body, Physics2D.Shape shape)
{
Physics2D.Fixture fixture = body.CreateFixture(shape);
if (tsMaterial != null)
{
fixture.Friction = tsMaterial.friction;
fixture.Restitution = tsMaterial.restitution;
}
}
private void CreateBody(Physics2D.World world)
{
Physics2D.Body body = Physics2D.BodyFactory.CreateBody(world);
if (tsMaterial == null)
{
tsMaterial = GetComponent <FPMaterial>();
}
Physics2D.Shape shape = Shape;
if (shape != null)
{
CreateBodyFixture(body, shape);
}
else
{
Physics2D.Shape[] shapes = CreateShapes();
for (int index = 0, length = shapes.Length; index < length; index++)
{
CreateBodyFixture(body, shapes[index]);
}
}
if (FPRigidBody == null)
{
body.BodyType = Physics2D.BodyType.Static;
}
else
{
if (FPRigidBody.isKinematic)
{
body.BodyType = KBEngine.Physics2D.BodyType.Kinematic;
}
else
{
body.BodyType = Physics2D.BodyType.Dynamic;
body.IgnoreGravity = !FPRigidBody.useGravity;
}
if (FPRigidBody.mass <= 0)
{
FPRigidBody.mass = 1;
}
body.FixedRotation = FPRigidBody.freezeZAxis;
body.Mass = FPRigidBody.mass;
body.TSLinearDrag = FPRigidBody.drag;
body.TSAngularDrag = FPRigidBody.angularDrag;
}
body.IsSensor = isTrigger;
body.CollidesWith = Physics2D.Category.All;
_body = body;
}
public void Restore(Physics2D.Body body)
{
body._angularDamping = this._angularDamping;
body._bodyType = this._bodyType;
body._inertia = this._inertia;
body._linearDamping = this._linearDamping;
body._mass = this._mass;
body._sleepingAllowed = this._sleepingAllowed;
body._awake = this._awake;
body._fixedRotation = this._fixedRotation;
body._enabled = this._enabled;
body._angularVelocity = this._angularVelocity;
body._linearVelocity = this._linearVelocity;
body._force = this._force;
body._invI = this._invI;
body._invMass = this._invMass;
body._sleepTime = this._sleepTime;
body._sweep = this._sweep;
body._torque = this._torque;
body._xf.p = this._xf.p;
body._xf.q = this._xf.q;
body._island = this._island;
bool lastDisabled = body.disabled;
body.disabled = this.disabled;
if (lastDisabled && !body.disabled)
{
Physics2D.ContactManager.physicsManager.GetGameObject(body).SetActive(true);
}
body.GravityScale = this.GravityScale;
body.IsBullet = this.IsBullet;
body.IgnoreCCD = this.IgnoreCCD;
body.IgnoreGravity = this.IgnoreGravity;
body.prevKinematicMass = this.prevKinematicMass;
body.prevKinematicInvMass = this.prevKinematicInvMass;
body.prevKinematicInertia = this.prevKinematicInertia;
body.prevKinematicInvI = this.prevKinematicInvI;
body.prevKinematicSweep = this.prevKinematicSweep;
List <Physics2D.Fixture> fixtureList = body.FixtureList;
for (int index = 0, length = this.shapesClone.Count; index < length; index++)
{
this.shapesClone[index].Restore(fixtureList[index].Shape);
}
}
public void Clone(IWorld iWorld, bool doChecksum)
{
Physics2D.World world = (Physics2D.World)iWorld;
Reset();
//whitebai 2017.5.9
//函数在动态库内，直接就干掉了，应该没啥用
if (doChecksum)
{
// checksum = ChecksumExtractor.GetEncodedChecksum();
}
clonedPhysics.Clear();
for (index = 0, length = world.BodyList.Count; index < length; index++)
{
Physics2D.Body b = world.BodyList[index];
BodyClone2D cloneB = poolRigidBodyClone.GetNew();
cloneB.Clone(b);
clonedPhysics.Add(b.BodyId, cloneB);
}
contactsClone.Clear();
for (index = 0, length = world.ContactList.Count; index < length; index++)
{
Physics2D.Contact c = world.ContactList[index];
ContactClone2D cClone = poolContactClone.GetNew();
cClone.Clone(c);
contactsClone.Add(cClone);
}
islandClone.Clone(world.Island);
toiClone.Clone(world._input);
dynamicTreeClone.Clone((Physics2D.DynamicTreeBroadPhase)world.ContactManager.BroadPhase);
this._worldHasNewFixture = world._worldHasNewFixture;
bodyCounter = Physics2D.Body._bodyIdCounter;
fixtureCounter = Physics2D.Fixture._fixtureIdCounter;
}
private void CollisionDetected(Physics2D.Body body1, Physics2D.Body body2, SyncFrame.Physics2D.Contact contact, string callbackName)
{
if (!gameObjectMap.ContainsKey(body1) || !gameObjectMap.ContainsKey(body2))
{
return;
}
GameObject b1 = gameObjectMap[body1];
GameObject b2 = gameObjectMap[body2];
if (b1 == null || b2 == null)
{
return;
}
b1.SendMessage(callbackName, GetCollisionInfo(body1, body2, contact), SendMessageOptions.DontRequireReceiver);
b2.SendMessage(callbackName, GetCollisionInfo(body2, body1, contact), SendMessageOptions.DontRequireReceiver);
//SyncFrameManager.UpdateCoroutines ();
}
private static object OverlapGeneric(Physics2D.Shape shape, FPVector2 position, Physics2D.BodySpecialSensor sensorType, int layerMask)
{
Physics2D.World world = (Physics2D.World)Physics2DWorldManager.instance.GetWorld();
Physics2D.Body body = Physics2D.BodyFactory.CreateBody(world);
body.CreateFixture(shape);
body.BodyType = Physics2D.BodyType.Static;
body.IsSensor = true;
body.CollidesWith = Physics2D.Category.All;
body.SpecialSensor = sensorType;
body.SpecialSensorMask = layerMask;
body.Position = position;
world.RemoveBody(body);
world.ProcessRemovedBodies();
if (body._specialSensorResults.Count > 0)
{
if (sensorType == Physics2D.BodySpecialSensor.ActiveOnce)
{
return(Physics2DWorldManager.instance.GetGameObject(body._specialSensorResults[0]).GetComponent <FPCollider2D>());
}
else
{
FPCollider2D[] result = new FPCollider2D[body._specialSensorResults.Count];
for (int i = 0; i < body._specialSensorResults.Count; i++)
{
result[i] = Physics2DWorldManager.instance.GetGameObject(body._specialSensorResults[i]).GetComponent <FPCollider2D>();
}
return(result);
}
}
return(null);
}
public void Restore(IWorld iWorld)
{
Physics2D.World world = (Physics2D.World)iWorld;
bodiesToRemove.Clear();
for (index = 0, length = world.BodyList.Count; index < length; index++)
{
Physics2D.Body rb = world.BodyList[index];
if (!clonedPhysics.ContainsKey(rb.BodyId))
{
bodiesToRemove.Add(rb);
}
}
for (index = 0, length = bodiesToRemove.Count; index < length; index++)
{
Physics2D.Body rb = bodiesToRemove[index];
world.RemoveBody(rb);
}
world.ProcessRemovedBodies();
for (index = 0, length = world.BodyList.Count; index < length; index++)
{
Physics2D.Body rb = world.BodyList[index];
if (clonedPhysics.ContainsKey(rb.BodyId))
{
BodyClone2D rbClone = clonedPhysics[rb.BodyId];
rbClone.Restore(rb);
}
}
for (index = 0, length = world.ContactList.Count; index < length; index++)
{
Physics2D.Contact c = world.ContactList[index];
world._contactPool.Enqueue(c);
}
world.ContactList.Clear();
contactDic.Clear();
for (index = 0, length = contactsClone.Count; index < length; index++)
{
ContactClone2D cClone = contactsClone[index];
Physics2D.Contact c = null;
if (world._contactPool.Count > 0)
{
c = world._contactPool.Dequeue();
}
else
{
c = new Physics2D.Contact();
}
cClone.Restore(c);
contactDic.Add(c.Key, c);
world.ContactList.Add(c);
}
contactEdgeDic.Clear();
for (index = 0, length = contactsClone.Count; index < length; index++)
{
ContactClone2D cClone = contactsClone[index];
contactDic[cClone.Key]._nodeA = cClone._nodeA.Restore(false, contactDic, contactEdgeDic);
contactDic[cClone.Key]._nodeB = cClone._nodeB.Restore(false, contactDic, contactEdgeDic);
}
for (index = 0, length = contactsClone.Count; index < length; index++)
{
ContactClone2D cClone = contactsClone[index];
contactDic[cClone.Key]._nodeA = cClone._nodeA.Restore(true, contactDic, contactEdgeDic);
contactDic[cClone.Key]._nodeB = cClone._nodeB.Restore(true, contactDic, contactEdgeDic);
}
for (index = 0, length = world.BodyList.Count; index < length; index++)
{
Physics2D.Body rb = world.BodyList[index];
if (clonedPhysics.ContainsKey(rb.BodyId))
{
BodyClone2D rbClone = clonedPhysics[rb.BodyId];
if (rbClone.contactEdgeClone != null)
{
rbClone.contactEdgeClone.Restore(false, contactDic, contactEdgeDic);
}
else
{
rb.ContactList = null;
}
}
}
for (index = 0, length = world.BodyList.Count; index < length; index++)
{
Physics2D.Body rb = world.BodyList[index];
if (clonedPhysics.ContainsKey(rb.BodyId))
{
BodyClone2D rbClone = clonedPhysics[rb.BodyId];
if (rbClone.contactEdgeClone != null)
{
rb.ContactList = rbClone.contactEdgeClone.Restore(true, contactDic, contactEdgeDic);
}
}
}
islandClone.Restore(world.Island, contactDic);
toiClone.Restore(world._input);
TreeNode <FixtureProxy>[] treeNodes = ((DynamicTreeBroadPhase)world.ContactManager.BroadPhase)._tree._nodes;
for (index = 0, length = treeNodes.Length; index < length; index++)
{
TreeNode <FixtureProxy> tn = treeNodes[index];
poolTreeFixtureProxy.GiveBack(tn);
}
dynamicTreeClone.Restore((DynamicTreeBroadPhase)world.ContactManager.BroadPhase);
world._worldHasNewFixture = this._worldHasNewFixture;
Body._bodyIdCounter = bodyCounter;
Fixture._fixtureIdCounter = fixtureCounter;
}
