public void Restore(Physics2D.Contact contact)
        {
            contact._type        = this._type;
            contact._toiCount    = this._toiCount;
            contact._toi         = this._toi;
            contact.Friction     = this.Friction;
            contact.Restitution  = this.Restitution;
            contact.TangentSpeed = this.TangentSpeed;
            contact.Enabled      = this.Enabled;
            contact.ChildIndexA  = this.ChildIndexA;
            contact.ChildIndexB  = this.ChildIndexB;
            contact.IsTouching   = this.IsTouching;
            contact.IslandFlag   = this.IslandFlag;
            contact.TOIFlag      = this.TOIFlag;
            contact.FilterFlag   = this.FilterFlag;
            contact.FixtureA     = this.FixtureA;
            contact.FixtureB     = this.FixtureB;

            contact.Manifold.LocalNormal = this.Manifold.LocalNormal;
            contact.Manifold.LocalPoint  = this.Manifold.LocalPoint;
            contact.Manifold.PointCount  = this.Manifold.PointCount;

            for (int i = 0; i < this.Manifold.PointCount; ++i)
            {
                contact.Manifold.Points[i] = this.Manifold.Points[i];
            }

            contact.Manifold.Type = this.Manifold.Type;
        }
        public void Clone(Physics2D.Contact contact)
        {
            this._type        = contact._type;
            this._toiCount    = contact._toiCount;
            this._toi         = contact._toi;
            this.Friction     = contact.Friction;
            this.Restitution  = contact.Restitution;
            this.TangentSpeed = contact.TangentSpeed;
            this.Enabled      = contact.Enabled;
            this.ChildIndexA  = contact.ChildIndexA;
            this.ChildIndexB  = contact.ChildIndexB;
            this.IsTouching   = contact.IsTouching;
            this.IslandFlag   = contact.IslandFlag;
            this.TOIFlag      = contact.TOIFlag;
            this.FilterFlag   = contact.FilterFlag;
            this.FixtureA     = contact.FixtureA;
            this.FixtureB     = contact.FixtureB;

            this._nodeA.Clone(contact._nodeA);
            this._nodeB.Clone(contact._nodeB);

            this.Manifold.LocalNormal = contact.Manifold.LocalNormal;
            this.Manifold.LocalPoint  = contact.Manifold.LocalPoint;
            this.Manifold.PointCount  = contact.Manifold.PointCount;

            for (int i = 0; i < contact.Manifold.PointCount; ++i)
            {
                this.Manifold.Points[i] = contact.Manifold.Points[i];
            }

            this.Manifold.Type = contact.Manifold.Type;
        }
        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;
        }
Exemple #4
0
        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;
        }