#42 started performance fixes for chunk generation

miepzerino

2025-04-03 d9d5b7b5c58a7b044b78ee7993f0a15e5b79f689

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Tilemaps;
 
public class TilePool : MonoBehaviour
{
    private Dictionary<Vector3Int, TileData> pooledTileData = new Dictionary<Vector3Int, TileData>();
    private int poolSize = 10000; // Adjust pool size as needed
    private Queue<TileData> availableTileData = new Queue<TileData>();
    private HashSet<Vector3Int> activeTilePositions = new HashSet<Vector3Int>();
 
    // Cache for rule tile data
    private Dictionary<CustomRuleTile, TileBase[]> tileDataCache = new Dictionary<CustomRuleTile, TileBase[]>();
 
    [System.Serializable]
    public class TileData
    {
        public Vector3Int position;
        public CustomRuleTile tileType;
        public bool isActive;
    }
 
    public void InitializePool(CustomRuleTile defaultTile)
    {
        pooledTileData.Clear();
        availableTileData.Clear();
        activeTilePositions.Clear();
 
        // Pre-calculate tile data for the default tile
        if (!tileDataCache.ContainsKey(defaultTile))
        {
            var tileData = new TileBase[9]; // Cache neighboring tile configurations
            tileDataCache[defaultTile] = tileData;
        }
 
        for (int i = 0; i < poolSize; i++)
        {
            availableTileData.Enqueue(new TileData
            {
                tileType = defaultTile,
                isActive = false
            });
        }
    }
 
    public TileData GetTileData(Vector3Int position, CustomRuleTile tileType)
    {
        if (!activeTilePositions.Contains(position))
        {
            if (availableTileData.Count > 0)
            {
                var tileData = availableTileData.Dequeue();
                tileData.position = position;
                tileData.tileType = tileType;
                tileData.isActive = true;
                pooledTileData[position] = tileData;
                activeTilePositions.Add(position);
                return tileData;
            }
        }
        return pooledTileData.GetValueOrDefault(position);
    }
 
    public void ReturnTileData(Vector3Int position)
    {
        if (pooledTileData.TryGetValue(position, out TileData tileData))
        {
            tileData.isActive = false;
            availableTileData.Enqueue(tileData);
            pooledTileData.Remove(position);
        }
    }
 
    public bool HasTileAt(Vector3Int position)
    {
        return pooledTileData.ContainsKey(position) && pooledTileData[position].isActive;
    }
}