public CoordInfo(CoordInfo fatherRange, QuadTreeAreaType childNodeType)
        {
            Center = fatherRange.Center;
            Range  = fatherRange.Range / 2;

            Init(childNodeType);
        }
        private void Init(QuadTreeAreaType childNodeType)
        {
            switch (childNodeType)
            {
            case QuadTreeAreaType.LeftBottom:
                Center.x -= Range.x / 2;
                Center.y -= Range.y / 2;
                break;

            case QuadTreeAreaType.LeftUp:
                Center.x -= Range.x / 2;
                Center.y += Range.y / 2;
                break;

            case QuadTreeAreaType.RightUp:
                Center.x += Range.x / 2;
                Center.y += Range.y / 2;
                break;

            case QuadTreeAreaType.RightBottom:
                Center.x += Range.x / 2;
                Center.y -= Range.y / 2;
                break;
            }
        }
        public QuadTreeNode InsertChild(QuadTreeAreaType childNodeType)
        {
            if (IsLeaf)
            {
                return(null);
            }

            CoordInfo childCoordRange = new CoordInfo(m_CoordRange, childNodeType);
            uint      childLayer      = m_Layer + 1;

            QuadTreeNode childNode;

            if (childLayer < QuadTreeConfig.MaxLayer)
            {
                childNode = new QuadTreeNode(childNodeType, childCoordRange, childLayer);
            }
            else
            {
                childNode = new QuadTreeLeafNode(childNodeType, childCoordRange);
            }

            m_Childs[(int)childNodeType] = childNode;

            return(childNode);
        }
Example #4
0
 private void BuildTree(QuadTreeNode root)
 {
     for (QuadTreeAreaType childNodeType = QuadTreeAreaType.LeftUp; childNodeType <= QuadTreeAreaType.LeftBottom; childNodeType++)
     {
         QuadTreeNode childNode = root.InsertChild(childNodeType);
         if (childNode != null)
         {
             BuildTree(childNode);
         }
     }
 }
        public QuadTreeNode(QuadTreeAreaType areaType, CoordInfo coordRange, uint layer, bool leaf = false)
        {
            if (!leaf)
            {
                m_Childs = new List <QuadTreeNode>(QuadTreeConfig.ChildCount);
                for (int i = 0; i < QuadTreeConfig.ChildCount; i++)
                {
                    m_Childs.Add(null);
                }
            }

            m_AreaType   = areaType;
            m_CoordRange = coordRange;
            m_Layer      = layer;
        }
        private QuadTreeNode Search(Vector3 targetPos)
        {
            QuadTreeAreaType areaType = Locate(targetPos);

            if (areaType == QuadTreeAreaType.None)
            {
                return(null);
            }

            var nextChild = m_Childs[(int)areaType];

            if (!nextChild.IsLeaf)
            {
                return(nextChild.Search(targetPos));
            }

            return(nextChild);
        }
Example #7
0
 public QuadTreeLeafNode(QuadTreeAreaType areaType, CoordInfo coordRange)
     : base(areaType, coordRange, QuadTreeConfig.MaxLayer, true)
 {
     m_GameObjects = new List <GameObject>();
 }