Question How does Tilemap.GetTilesRangeNonAlloc work?

According to the documentation, it retrieves non-null tiles within the range given to it.

So, how come if I have something like this

Code (CSharp):

1. private TileBase[] tiles = new TileBase[32768];
2. private Vector3Int[] positions = new Vector3Int[32768];
3.  
4. BoundsInt bounds = new(0, 0, 0, 5, 5, 1);
5. int count = map.GetTilesRangeNonAlloc(bounds.min, bounds.max, positions, tiles);

for a tilemap with cellBounds = 128x20x1, I get a count returned of 553? I do not think it is possible to have 553 tiles within this range. It returns tiles well out of the range given.

If I use GetTilesBlock() with the same bounds, it returns the correct size of 25. What's GetTilesRangeNonAlloc doing?

Unity version: 2021.2.10.

 

It doesn't say "retrieves non-null tiles within the range given to it" but rather "Retrieves an array of Tiles within the given range."

The numbers do seem wrong. Have you tries not using a boundsInt but specifying the positions directly as in

int count = map.GetTilesRangeNonAlloc(Vector3Int.zero, new Vector3(5,5,1), positions, tiles)

 

Yes, doing so gives the same results. And true about null, though it does appear to not return null tiles. Otherwise, requiring an array of positions would be strange I would think.

 

I made a new 2D URP project to test this in isolation. All I did is I added a tilemap to the scene and a test script with this code:

Code (CSharp):

1. public class TilemapTest : MonoBehaviour
2. {
3.     private Tilemap map;
4.  
5.     private void Awake()
6.     {
7.         map = GetComponentInChildren<Tilemap>();
8.  
9.         BoundsInt bounds = new(Vector3Int.zero, new(128, 128, 1));
10.  
11.         Tile[] tiles = new Tile[bounds.size.x * bounds.size.y];
12.  
13.         for (int i = 0; i < tiles.Length; ++i)
14.             tiles[i] = ScriptableObject.CreateInstance<Tile>();
15.  
16.         map.SetTilesBlock(bounds, tiles);
17.     }
18.  
19.     private void Update()
20.     {
21.         if (Input.GetKeyDown(KeyCode.Space))
22.         {
23.             Vector3Int start = Vector3Int.zero;
24.             Vector3Int end = new(5, 5, 1);
25.  
26.             int count = map.GetTilesRangeCount(start, end);
27.             Debug.Log("GetTilesRangeCount: " + count);
28.  
29.             TileBase[] tiles = new TileBase[ushort.MaxValue];
30.             Vector3Int[] positions = new Vector3Int[ushort.MaxValue];
31.  
32.             count = map.GetTilesRangeNonAlloc(start, end, positions, tiles);
33.             Debug.Log("GetTilesRangeNonAlloc: " + count);
34.  
35.             int nonNull = 0;
36.  
37.             for (int i = 0; i < tiles.Length; ++i)
38.             {
39.                 if (tiles[i] != null)
40.                     ++nonNull;
41.             }
42.  
43.             Debug.Log("Non-Null Returned: " + nonNull);
44.         }
45.     }
46. }

Upon pressing space I get this:

GetTilesRangeCount: 646
GetTilesRangeNonAlloc: 646
Non-Null Returned: 646

This must be a bug, right?

 

I don't know if it's a bug. I haven't use GetTilesRangeNonAlloc in my asset so I'm just guessing here...

GetTilesRangeCount doc says that the range is inclusive. So 0->5 is a range of 6. The example that they show has the Z param set to zero for both start and end, but you have it at 1. Still, 646 is weird.

Use a debugger and examine exactly what's returned in the arrays. Sometimes, and this is hidden internally and only my opinion since I don't have visibility into the engine code, an empty position is returned as a TileBase instance. You can see this if you use the TilePalette in select mode and view the selection inspector when you click on an empty position. A TileBase instance is what's there. Hard to tell if this is just for display or not, even by examining the editor code.

It certainly is confusing that GetTilesRangeCount returns 646 here.

Try using End = 5,5,0 ??

Aside from that I'd probably do a bug report at this point. Or the docs may not reflect what's really going on. Hard to tell since I can't find any usage of this method anywhere in the tilemap editor, etc.

 

It looks like it returned every tile from the rows at y = 0, 1, 2, 3, and 4. Not bounded by the range specified on the x axis. But then it stopped with the last tile being at 5, 5, 0. Since the map is 128 wide, that would be 128 * 5 + 6 tiles from row 5, giving 646. So it appears it's simply ignoring the x boundary.

If I use end as 5, 5, 0 nothing changes (which it wouldn't if what I said above is correct).

 

Really odd.

 

Thanks for the clarification. This means, then, that there isn’t a way to have the behavior of GetTilesBlock without array allocation? Or did I miss it?

If not, that’s a shame. I need exactly that for several things I’m doing.

 

I’m on 2021.2.10. Glad to hear this option will be added!

 

that's a remarkable explanation.

 

Yep, thanks for the explanation. I would also appreciate a version of GetTilesRangeNonAlloc which behaves like GetTilesBlock in regard of the tiles returned.

 

In the latest Unity version 2021.2.19 they added a new method GetTilesBlockNonAlloc for the tilemap:

https://docs.unity3d.com/2021.2/Doc...e/Tilemaps.Tilemap.GetTilesBlockNonAlloc.html

I did not tested it but reads like to solve the allocation problem with large amounts of tiles.