예제 #1
0
 private void ReturnNode(BSPCollisionNode node)
 {
     cache[tail++] = node;
     if (tail == MAX_SIZE)
     {
         tail = 0;
     }
     size = MathUtils.Min(size + 1, MAX_SIZE);
     if (node.GetLeft() != null || node.GetRight() != null)
     {
         throw new Exception("Size Error !");
     }
 }
예제 #2
0
        public ActorNode(Actor actor, BSPCollisionNode node)
        {
            this.actor = actor;
            this.node = node;
            ActorNode first = BSPCollisionChecker.GetNodeForActor(actor);
            this.next = first;
            BSPCollisionChecker.SetNodeForActor(actor, this);
            if (this.next != null)
            {
                this.next.prev = this;
            }

            this.mark = true;
        }
예제 #3
0
 public Actor GetOnlyIntersectingUp(RectBox r,
         CollisionQuery query, Actor actor, BSPCollisionNode start)
 {
     for (; start != null && !start.GetArea().Contains(r); )
     {
         Actor res = this.CheckForOnlyCollision(actor, start, query);
         if (res != null)
         {
             return res;
         }
         start = start.GetParent();
     }
     return null;
 }
예제 #4
0
 private Actor GetOnlyObjectDownTree(Actor ignore, RectBox r,
         CollisionQuery query, BSPCollisionNode startNode)
 {
     if (startNode == null)
     {
         return null;
     }
     else
     {
         lock (cacheNodeStack)
         {
             cacheNodeStack.Clear();
             if (startNode != null)
             {
                 CollectionUtils.Add(cacheNodeStack, startNode);
             }
             while (!(cacheNodeStack.Count == 0))
             {
                 BSPCollisionNode node = (BSPCollisionNode)cacheNodeStack
                         .RemoveLast();
                 if (node.GetArea().Intersects(r))
                 {
                     Actor res = this.CheckForOnlyCollision(ignore, node,
                             query);
                     if (res != null)
                     {
                         return res;
                     }
                     BSPCollisionNode left = node.GetLeft();
                     BSPCollisionNode right = node.GetRight();
                     if (left != null)
                     {
                         CollectionUtils.Add(cacheNodeStack, left);
                     }
                     if (right != null)
                     {
                         CollectionUtils.Add(cacheNodeStack, right);
                     }
                 }
             }
         }
         return null;
     }
 }
예제 #5
0
 private Actor CheckForOnlyCollision(Actor ignore,
         BSPCollisionNode node, CollisionQuery query)
 {
     if (node == null)
     {
         return null;
     }
     IIterator i = node.GetActorsIterator();
     Actor candidate;
     do
     {
         if (!i.HasNext())
         {
             return null;
         }
         candidate = (Actor)i.Next();
     } while (ignore == candidate || !query.CheckCollision(candidate));
     return candidate;
 }
예제 #6
0
 private void GetIntersectingObjects(float[] r,
         CollisionQuery query, ISet resultSet, BSPCollisionNode startNode)
 {
     lock (cacheNodeStack)
     {
         cacheNodeStack.Clear();
         try
         {
             if (startNode != null)
             {
                 CollectionUtils.Add(cacheNodeStack, startNode);
             }
             int idx = 0;
             for (; !(cacheNodeStack.Count == 0) && idx < MAX_SIZE; )
             {
                 BSPCollisionNode node = (BSPCollisionNode)cacheNodeStack
                         .RemoveLast();
                 lock (node)
                 {
                     if (node.GetArea().Intersects(r[0], r[1], r[2], r[3]))
                     {
                         IIterator i = node.GetActorsIterator();
                         for (; i.HasNext(); )
                         {
                             Actor left = (Actor)i.Next();
                             if (query.CheckCollision(left)
                                     && !CollectionUtils.Contains(left, resultSet))
                             {
                                 CollectionUtils.Add(resultSet, left);
                             }
                         }
                         BSPCollisionNode left1 = node.GetLeft();
                         BSPCollisionNode right = node.GetRight();
                         if (left1 != null)
                         {
                             CollectionUtils.Add(cacheNodeStack, left1);
                         }
                         if (right != null)
                         {
                             CollectionUtils.Add(cacheNodeStack, right);
                         }
                     }
                 }
                 idx++;
             }
         }
         catch (Exception ex)
         {
             Loon.Utils.Debugging.Log.Exception(ex);
         }
     }
 }
예제 #7
0
        private BSPCollisionNode CheckRemoveNode(BSPCollisionNode node)
        {
            int idx = 0;
            for (; idx < MAX_SIZE; )
            {
                if (node != null && node.IsEmpty())
                {
                    BSPCollisionNode parent = node.GetParent();
                    int side = (parent != null) ? parent.GetChildSide(node) : 3;
                    BSPCollisionNode left = node.GetLeft();
                    BSPCollisionNode right = node.GetRight();
                    if (left == null)
                    {
                        if (parent != null)
                        {
                            if (right != null)
                            {
                                right.SetArea(node.GetArea());
                            }
                            parent.SetChild(side, right);
                        }
                        else
                        {
                            this.bspTree = right;
                            if (right != null)
                            {
                                right.SetParent((BSPCollisionNode)null);
                            }
                        }
                        node.SetChild(1, (BSPCollisionNode)null);
                        ReturnNode(node);
                        node = parent;
                        continue;
                    }

                    if (right == null)
                    {
                        if (parent != null)
                        {
                            if (left != null)
                            {
                                left.SetArea(node.GetArea());
                            }

                            parent.SetChild(side, left);
                        }
                        else
                        {
                            this.bspTree = left;
                            if (left != null)
                            {
                                left.SetParent((BSPCollisionNode)null);
                            }
                        }

                        node.SetChild(0, (BSPCollisionNode)null);
                        ReturnNode(node);
                        node = parent;
                        continue;
                    }
                }
                idx++;
                return node;
            }
            return null;
        }
예제 #8
0
        private void InsertObject(Actor actor, RectBox actorBounds, RectBox bounds,
                RectBox area, BSPCollisionNode node, RectBox result1,
                RectBox result2)
        {
            if (!node.ContainsActor(actor))
            {
                if (!node.IsEmpty()
                        && (area.width > actorBounds.width || area.height > actorBounds.height))
                {
                    RectBox leftArea = node.GetLeftArea();
                    RectBox rightArea = node.GetRightArea();
                    RectBox leftIntersects = RectBox.GetIntersection(leftArea,
                            bounds, result1);
                    RectBox rightIntersects = RectBox.GetIntersection(rightArea,
                            bounds, result2);
                    BSPCollisionNode newRight;
                    if (leftIntersects != null)
                    {
                        if (node.GetLeft() == null)
                        {
                            newRight = this.CreateNewNode(leftArea);
                            newRight.AddActor(actor);
                            node.SetChild(0, newRight);
                        }
                        else
                        {
                            this.InsertObject(actor, actorBounds, leftIntersects,
                                    leftArea, node.GetLeft(), result1, result2);
                        }
                    }
                    if (rightIntersects != null)
                    {
                        if (node.GetRight() == null)
                        {
                            newRight = this.CreateNewNode(rightArea);
                            newRight.AddActor(actor);
                            node.SetChild(1, newRight);
                        }
                        else
                        {
                            this.InsertObject(actor, actorBounds, rightIntersects,
                                    rightArea, node.GetRight(), result1, result2);
                        }
                    }

                }
                else
                {
                    node.AddActor(actor);
                }
            }
        }
예제 #9
0
        public void AddObject(Actor actor)
        {
            RectBox bounds = this.GetActorBounds(actor);
            float by;
            if (this.bspTree == null)
            {
                byte treeArea;
                if (bounds.width > bounds.height)
                {
                    treeArea = 0;
                    by = bounds.GetMiddleX();
                }
                else
                {
                    treeArea = 1;
                    by = bounds.GetMiddleY();
                }

                this.bspTree = GetBSPNode();
                this.bspTree.GetArea().Copy(bounds);
                this.bspTree.SetSplitAxis(treeArea);
                this.bspTree.SetSplitPos(by);
                this.bspTree.AddActor(actor);
            }
            else
            {
                int idx = 0;
                RectBox treeArea1 = this.bspTree.GetArea();
                RectBox result1 = new RectBox();
                RectBox result2 = new RectBox();
                for (; !treeArea1.Contains(bounds) && idx < MAX_SIZE; )
                {
                    RectBox newArea;
                    BSPCollisionNode newTop;
                    if (bounds.GetX() < treeArea1.GetX())
                    {
                        by = (treeArea1.GetX() - treeArea1.width);
                        newArea = new RectBox(by, treeArea1.GetY(),
                                treeArea1.GetRight() - by, treeArea1.height);
                        newTop = GetBSPNode();
                        newTop.GetArea().Copy(newArea);
                        newTop.SetSplitAxis(0);
                        newTop.SetSplitPos(treeArea1.GetX());
                        newTop.SetChild(1, this.bspTree);
                        this.bspTree = newTop;
                        treeArea1 = newArea;
                    }
                    if (bounds.GetRight() > treeArea1.GetRight())
                    {
                        by = (treeArea1.GetRight() + treeArea1.width);
                        newArea = new RectBox(treeArea1.GetX(), treeArea1.GetY(),
                                by - treeArea1.GetX(), treeArea1.height);
                        newTop = GetBSPNode();
                        newTop.GetArea().Copy(newArea);
                        newTop.SetSplitAxis(0);
                        newTop.SetSplitPos(treeArea1.GetRight());
                        newTop.SetChild(0, this.bspTree);
                        this.bspTree = newTop;
                        treeArea1 = newArea;
                    }
                    if (bounds.GetY() < treeArea1.GetY())
                    {
                        by = (treeArea1.GetY() - treeArea1.height);
                        newArea = new RectBox(treeArea1.GetX(), by,
                                treeArea1.width, treeArea1.GetBottom() - by);
                        newTop = GetBSPNode();
                        newTop.GetArea().Copy(newArea);
                        newTop.SetSplitAxis(1);
                        newTop.SetSplitPos(treeArea1.GetY());
                        newTop.SetChild(1, this.bspTree);
                        this.bspTree = newTop;
                        treeArea1 = newArea;
                    }
                    if (bounds.GetBottom() > treeArea1.GetBottom())
                    {
                        by = (treeArea1.GetBottom() + treeArea1.height);
                        newArea = new RectBox(treeArea1.GetX(), treeArea1.GetY(),
                                treeArea1.width, by - treeArea1.GetY());
                        newTop = GetBSPNode();
                        newTop.GetArea().Copy(newArea);
                        newTop.SetSplitAxis(1);
                        newTop.SetSplitPos(treeArea1.GetBottom());
                        newTop.SetChild(0, this.bspTree);
                        this.bspTree = newTop;
                        treeArea1 = newArea;
                    }
                    idx++;
                }

                this.InsertObject(actor, bounds, bounds, treeArea1, this.bspTree,
                        result1, result2);
            }

        }
예제 #10
0
        public void Dispose()
        {
            if (node != null)
            {
                node = null;
            }
            if (next != null)
            {
                next.Dispose();
                next = null;
            }
            if (prev != null)
            {
                prev.Dispose();
                prev = null;
            }

        }