Beispiel #1
0
        /// <inheritdoc/>
        public override IEnumerable <Pair <T> > GetOverlaps(ISpatialPartition <T> otherPartition)
        {
            UpdateInternal();
            var overlapsStatic  = StaticPartition.GetOverlaps(otherPartition);
            var overlapsDynamic = DynamicPartition.GetOverlaps(otherPartition);

#if !POOL_ENUMERABLES
            return(overlapsStatic.Concat(overlapsDynamic));
#else
            return(ConcatWork <Pair <T> > .Create(overlapsStatic, overlapsDynamic));
#endif
        }
Beispiel #2
0
        /// <inheritdoc/>
        public override IEnumerable <Pair <T> > GetOverlaps(Vector3F scale, Pose pose, ISpatialPartition <T> otherPartition, Vector3F otherScale, Pose otherPose)
        {
            UpdateInternal();
            var overlapsStatic  = StaticPartition.GetOverlaps(scale, pose, otherPartition, otherScale, otherPose);
            var overlapsDynamic = DynamicPartition.GetOverlaps(scale, pose, otherPartition, otherScale, otherPose);

#if !POOL_ENUMERABLES
            return(overlapsStatic.Concat(overlapsDynamic));
#else
            return(ConcatWork <Pair <T> > .Create(overlapsStatic, overlapsDynamic));
#endif
        }
        /// <inheritdoc/>
        public override IEnumerable <T> GetOverlaps(Ray ray)
        {
            UpdateInternal();
            var overlapsStatic  = StaticPartition.GetOverlaps(ray);
            var overlapsDynamic = DynamicPartition.GetOverlaps(ray);

#if !POOL_ENUMERABLES
            return(overlapsStatic.Concat(overlapsDynamic));
#else
            return(ConcatWork <T> .Create(overlapsStatic, overlapsDynamic));
#endif
        }
    /// <inheritdoc/>
    public override IEnumerable<T> GetOverlaps(Ray ray)
    {
      UpdateInternal();
      var overlapsStatic = StaticPartition.GetOverlaps(ray);
      var overlapsDynamic = DynamicPartition.GetOverlaps(ray);


      return overlapsStatic.Concat(overlapsDynamic);
#else
      return ConcatWork<T>.Create(overlapsStatic, overlapsDynamic);

    }
Beispiel #5
0
    /// <inheritdoc/>
    public override IEnumerable<Pair<T>> GetOverlaps(Vector3 scale, Pose pose, ISpatialPartition<T> otherPartition, Vector3 otherScale, Pose otherPose)
    {
      UpdateInternal();
      var overlapsStatic = StaticPartition.GetOverlaps(scale, pose, otherPartition, otherScale, otherPose);
      var overlapsDynamic = DynamicPartition.GetOverlaps(scale, pose, otherPartition, otherScale, otherPose);


      return overlapsStatic.Concat(overlapsDynamic);
#else
      return ConcatWork<Pair<T>>.Create(overlapsStatic, overlapsDynamic);

    }
Beispiel #6
0
    /// <inheritdoc/>
    public override IEnumerable<Pair<T>> GetOverlaps(ISpatialPartition<T> otherPartition)
    {
      UpdateInternal();
      var overlapsStatic = StaticPartition.GetOverlaps(otherPartition);
      var overlapsDynamic = DynamicPartition.GetOverlaps(otherPartition);


      return overlapsStatic.Concat(overlapsDynamic);
#else
      return ConcatWork<Pair<T>>.Create(overlapsStatic, overlapsDynamic);

    }
Beispiel #7
0
        /// <summary>
        /// Recomputes the self-overlaps.
        /// </summary>
        private void UpdateSelfOverlaps()
        {
            if (!EnableSelfOverlaps)
            {
                return;
            }

            SelfOverlaps.Clear();

            // Get intra-overlaps from static partition.
            AddSelfOverlaps(StaticPartition.GetOverlaps());

            // Get intra-overlaps from dynamic partition.
            AddSelfOverlaps(DynamicPartition.GetOverlaps());

            // Get inter-overlaps between static and dynamic partition.
            AddSelfOverlaps(StaticPartition.GetOverlaps(DynamicPartition));
        }
Beispiel #8
0
        private void UpdateBroadPhase()
        {
            if (_broadPhase == null)
            {
                return;
            }

            // Mark intra-overlaps of static partition.
            AddOrMarkAsUsed(StaticPartition.GetOverlaps());

            // Mark intra-overlaps of dynamic partition.
            AddOrMarkAsUsed(DynamicPartition.GetOverlaps());

            // Mark inter-overlaps between static and dynamic partition.
            AddOrMarkAsUsed(StaticPartition.GetOverlaps(DynamicPartition));

            // Remove all unused candidate pairs from broad phase.
            _broadPhase.RemoveUnused();
        }
Beispiel #9
0
 /// <inheritdoc/>
 internal override void OnUpdate()
 {
     StaticPartition.Update(false);
     DynamicPartition.Update(false);
 }
Beispiel #10
0
        internal override void OnUpdate(bool forceRebuild, HashSet <T> addedItems, HashSet <T> removedItems, HashSet <T> invalidItems)
        {
            // First, remove invalid items.
            foreach (T removedItem in removedItems)
            {
                if (!StaticPartition.Remove(removedItem))
                {
                    // Item was not in the static partition, must be in dynamic partition.
                    bool removed = DynamicPartition.Remove(removedItem);
                    Debug.Assert(removed, "Item not found in dynamic partition.");

                    removed = _previousStage.Remove(removedItem);
                    Debug.Assert(removed, "Item not found in previous stage.");
                }
            }

            // Second, add all new items.
            // New items are considered as dynamic.
            foreach (T addedItem in addedItems)
            {
                _currentStage.Add(addedItem);
                DynamicPartition.Add(addedItem);
            }

            // Handle invalid items.
            if (invalidItems != null)
            {
                // Partial invalidation.
                foreach (T invalidItem in invalidItems)
                {
                    if (StaticPartition.Remove(invalidItem))
                    {
                        // Item was previously in static partition.
                        // --> Move it into the dynamic partition.
                        _currentStage.Add(invalidItem);
                        DynamicPartition.Add(invalidItem);
                    }
                    else
                    {
                        // Item was not in the static partition, must be in dynamic partition.
                        bool removed = _previousStage.Remove(invalidItem);
                        Debug.Assert(removed, "Item not found in previous stage.");

                        _currentStage.Add(invalidItem);
                        DynamicPartition.Invalidate(invalidItem);
                    }
                }

                if (_previousStage.Count > 0)
                {
                    // Move static objects in dynamic partition back to static partition.
                    foreach (T item in _previousStage)
                    {
                        bool removed = DynamicPartition.Remove(item);
                        Debug.Assert(removed, "Item not found in dynamic partition.");

                        StaticPartition.Add(item);
                    }

                    _previousStage.Clear();
                }
            }
            else
            {
                // Full invalidation.
                StaticPartition.Invalidate();
                DynamicPartition.Invalidate();

                // We could move all static items into the dynamic partition. However, we do not know the
                // cause of the invalidation. For now, we keep all static items in static stage and move all
                // previously dynamic items into the current stage.
                // --> All partitions keep their items. (We need to validate whether this is the right
                //     solution in practice. However, in practice the DualPartition<T> should only be used
                //     in the collision detection broad-phase where Invalidate() is never used.)
                foreach (T item in _previousStage)
                {
                    _currentStage.Add(item);
                }

                _previousStage.Clear();
            }

            // Swap current and previous stage.
            MathHelper.Swap(ref _currentStage, ref _previousStage);

            // Update static and dynamic partition.
            // TODO: Update partitions in parallel!
            StaticPartition.Update(forceRebuild);
            DynamicPartition.Update(forceRebuild);

            UpdateAabb();
            UpdateBroadPhase();
            UpdateSelfOverlaps();
        }
Beispiel #11
0
 public DynamicEnumerator(DynamicPartition outer)
 {
     Outer   = outer;
     Pending = new Queue <DeserializeDynamicTests._AllFloatsStruct>(Capacity);
 }