Beispiel #1
0
        public void TestGrowQuad()
        {
            var source = Rect.MinMaxRect(0, 0, 1, 1);

            var targets = new[] {
                new Vector2(0, 0),
                new Vector2(1, 0),
                new Vector2(0, 1),
                new Vector2(1, 1)
            };

            var required = new[]
            {
                Rect.MinMaxRect(-1, -1, 1, 1),
                Rect.MinMaxRect(0, -1, 2, 1),
                Rect.MinMaxRect(-1, 0, 1, 2),
                Rect.MinMaxRect(0, 0, 2, 2)
            };

            var sourceIndices = new[]
            {
                3, 2, 1, 0
            };

            for (int i = 0; i < 4; i++)
            {
                var quad = QuadTreeUtils.GrowQuad(source, targets[i], out var i2, out var i3);
                Assert.AreEqual(i, i2);
                Assert.AreEqual(required[i], quad, $"quadrant {i}");
                Assert.AreEqual(sourceIndices[i], i3);
            }
        }
Beispiel #2
0
        public void TestEncapsulates()

        {
            var rectA = Rect.MinMaxRect(-1, -1, 2, 2);
            var rectB = Rect.MinMaxRect(0, 0, 1, 1);
            var rectC = Rect.MinMaxRect(-2, -2, 0, 0);
            var rectD = Rect.MinMaxRect(1, 1, 3, 3);

            Assert.IsTrue(QuadTreeUtils.Encapsulates(rectA, rectB));
            Assert.IsFalse(QuadTreeUtils.Encapsulates(rectA, rectC));
            Assert.IsFalse(QuadTreeUtils.Encapsulates(rectA, rectD));
        }
Beispiel #3
0
        public void TestQuadIndex()
        {
            var root    = Rect.MinMaxRect(-1, -1, 2, 2);
            var targets = new[] {
                new Vector2(0, 0),
                new Vector2(1, 0),
                new Vector2(0, 1),
                new Vector2(1, 1)
            };

            for (int i = 0; i < 4; i++)
            {
                int i2 = QuadTreeUtils.GetQuadIndex(root, targets[i]);
                Assert.AreEqual(i, i2);
            }
        }
Beispiel #4
0
        public void TestDevideQuads()
        {
            var root = Rect.MinMaxRect(0, 0, 2, 2);

            var required = new[]
            {
                Rect.MinMaxRect(0, 0, 1, 1),
                Rect.MinMaxRect(1, 0, 2, 1),
                Rect.MinMaxRect(0, 1, 1, 2),
                Rect.MinMaxRect(1, 1, 2, 2)
            };

            var subs = QuadTreeUtils.DevideQuads(root);

            CollectionAssert.AreEqual(required, subs);
        }
Beispiel #5
0
        private void SetupQuadTree()
        {
            Vector2 bottomLeft = Vector2.one * (_terrain.Config.TotalTerrainSize * -0.5f);

            _tree = QuadTreeUtils.Create <GrassPatch>(
                _terrain.Config.TotalTerrainSize,
                _terrain.Config.PatchSize,
                bottomLeft,
                (node) => {
                // Construct a node, lookup and cache its center terrain height
                Vector2 center       = node.GetCenter();
                Vector3 position     = To3D(center);
                TerrainTile tile     = _terrain.GetTile(position);
                Vector2 terrainCoord = new Vector2(
                    (center.x - tile.transform.position.x) / _terrain.Config.TileSize,
                    (center.y - tile.transform.position.z) / _terrain.Config.TileSize);
                float height = tile.Terrain.terrainData.GetInterpolatedHeight(terrainCoord.x, terrainCoord.y);
                var patch    = new GrassPatch(node.Coord, height);
                return(patch);
            });

            _traversalData = new TraversalData(_tree.MaxDepth, _terrain.Config.PatchSize, _config.StreamRadius);
        }