Box2DX.Collision.BroadPhase.CreateProxy C# (CSharp) Method

		public ushort CreateProxy(AABB aabb, object userData)
		{
			Box2DXDebug.Assert(_proxyCount < Settings.MaxProxies);
			Box2DXDebug.Assert(_freeProxy != PairManager.NullProxy);

			ushort proxyId = _freeProxy;
			Proxy proxy = _proxyPool[proxyId];
			_freeProxy = proxy.Next;

			proxy.OverlapCount = 0;
			proxy.UserData = userData;

			int boundCount = 2 * _proxyCount;

			ushort[] lowerValues = new ushort[2], upperValues = new ushort[2];
			ComputeBounds(out lowerValues, out upperValues, aabb);

			for (int axis = 0; axis < 2; ++axis)
			{
				Bound[] bounds = _bounds[axis];
				int lowerIndex, upperIndex;
				Query(out lowerIndex, out upperIndex, lowerValues[axis], upperValues[axis], bounds, boundCount, axis);

#warning "Check this"
				//memmove(bounds + upperIndex + 2, bounds + upperIndex, (boundCount - upperIndex) * sizeof(b2Bound));				
				Bound[] tmp = new Bound[boundCount - upperIndex];
				for (int i = 0; i < (boundCount - upperIndex); i++)
				{
					tmp[i] = bounds[upperIndex + i].Clone();
				}
				for (int i = 0; i < (boundCount - upperIndex); i++)
				{
					bounds[upperIndex + 2 + i] = tmp[i];
				}

				//memmove(bounds + lowerIndex + 1, bounds + lowerIndex, (upperIndex - lowerIndex) * sizeof(b2Bound));
				tmp = new Bound[upperIndex - lowerIndex];
				for (int i = 0; i < (upperIndex - lowerIndex); i++)
				{
					tmp[i] = bounds[lowerIndex + i].Clone();
				}
				for (int i = 0; i < (upperIndex - lowerIndex); i++)
				{
					bounds[lowerIndex + 1 + i] = tmp[i];
				}

				// The upper index has increased because of the lower bound insertion.
				++upperIndex;

				// Copy in the new bounds.
				bounds[lowerIndex].Value = lowerValues[axis];
				bounds[lowerIndex].ProxyId = proxyId;
				bounds[upperIndex].Value = upperValues[axis];
				bounds[upperIndex].ProxyId = proxyId;

				bounds[lowerIndex].StabbingCount = lowerIndex == 0 ? (ushort)0 : bounds[lowerIndex - 1].StabbingCount;
				bounds[upperIndex].StabbingCount = bounds[upperIndex - 1].StabbingCount;

				// Adjust the stabbing count between the new bounds.
				for (int index = lowerIndex; index < upperIndex; ++index)
				{
					++bounds[index].StabbingCount;
				}

				// Adjust the all the affected bound indices.
				for (int index = lowerIndex; index < boundCount + 2; ++index)
				{
					Proxy proxy_ = _proxyPool[bounds[index].ProxyId];
					if (bounds[index].IsLower)
					{
						proxy_.LowerBounds[axis] = (ushort)index;
					}
					else
					{
						proxy_.UpperBounds[axis] = (ushort)index;
					}
				}
			}

			++_proxyCount;

			Box2DXDebug.Assert(_queryResultCount < Settings.MaxProxies);

			// Create pairs if the AABB is in range.
			for (int i = 0; i < _queryResultCount; ++i)
			{
				Box2DXDebug.Assert(_queryResults[i] < Settings.MaxProxies);
				Box2DXDebug.Assert(_proxyPool[_queryResults[i]].IsValid);

				_pairManager.AddBufferedPair(proxyId, _queryResults[i]);
			}

			_pairManager.Commit();

			if (IsValidate)
			{
				Validate();
			}

			// Prepare for next query.
			_queryResultCount = 0;
			IncrementTimeStamp();

			return proxyId;
		}

        internal void CreateProxy(BroadPhase broadPhase, XForm transform)
        {
            Box2DXDebug.Assert(this._proxyId == PairManager.NullProxy);
            AABB aabb;

            this.ComputeAABB(out aabb, transform);
            bool flag = broadPhase.InRange(aabb);

            Box2DXDebug.Assert(flag);
            if (flag)
            {
                this._proxyId = broadPhase.CreateProxy(aabb, this);
            }
            else
            {
                this._proxyId = PairManager.NullProxy;
            }
        }