535 lines
17 KiB
C#
535 lines
17 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using UnityEngine;
|
|
using UnityEngine.AddressableAssets;
|
|
using UnityEngine.ResourceManagement.AsyncOperations;
|
|
|
|
public class GeoTileAddressablesLoader : MonoBehaviour
|
|
{
|
|
[Header("References")]
|
|
[SerializeField] private Transform player;
|
|
[SerializeField] private Transform tilesParent;
|
|
|
|
[Header("Paths")]
|
|
[SerializeField] private string tileBundleFolderName = "TileBundles";
|
|
[SerializeField] private string manifestFileName = "TileManifest.json";
|
|
[SerializeField] private string buildingManifestFileName = "TileBuildingsManifest.json";
|
|
[SerializeField] private string buildTargetFolderOverride = "";
|
|
|
|
[Header("Streaming")]
|
|
[SerializeField] private float loadRadiusMeters = 1500f;
|
|
[SerializeField] private float unloadRadiusMeters = 2000f;
|
|
[SerializeField] private float updateInterval = 0.5f;
|
|
[SerializeField] private int maxConcurrentLoads = 2;
|
|
[SerializeField] private bool verboseLogging = false;
|
|
|
|
[Header("Buildings (2km blocks)")]
|
|
[SerializeField] private bool loadBuildingsFor2kmBlocks = true;
|
|
[SerializeField] private int buildingBlockSizeInTiles = 2;
|
|
|
|
private TileManifest manifest;
|
|
private TileManifest buildingManifest;
|
|
private readonly Dictionary<string, TileEntry> tiles = new Dictionary<string, TileEntry>();
|
|
private readonly Dictionary<string, GameObject> loaded = new Dictionary<string, GameObject>();
|
|
private readonly HashSet<string> loading = new HashSet<string>();
|
|
private readonly HashSet<string> queued = new HashSet<string>();
|
|
private readonly Queue<string> loadQueue = new Queue<string>();
|
|
private readonly Dictionary<string, TileEntry> buildingTiles = new Dictionary<string, TileEntry>();
|
|
private readonly Dictionary<string, GameObject> buildingLoaded = new Dictionary<string, GameObject>();
|
|
private readonly HashSet<string> buildingLoading = new HashSet<string>();
|
|
private readonly HashSet<string> buildingQueued = new HashSet<string>();
|
|
private readonly Queue<string> buildingLoadQueue = new Queue<string>();
|
|
private readonly Dictionary<string, string> tileBlockKey = new Dictionary<string, string>();
|
|
private readonly Dictionary<string, string> blockBuildingKey = new Dictionary<string, string>();
|
|
|
|
private bool initialized;
|
|
private float nextUpdateTime;
|
|
|
|
private void OnValidate()
|
|
{
|
|
if (unloadRadiusMeters < loadRadiusMeters)
|
|
unloadRadiusMeters = loadRadiusMeters;
|
|
if (maxConcurrentLoads < 1)
|
|
maxConcurrentLoads = 1;
|
|
if (updateInterval < 0.05f)
|
|
updateInterval = 0.05f;
|
|
if (buildingBlockSizeInTiles < 1)
|
|
buildingBlockSizeInTiles = 1;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
if (tilesParent == null)
|
|
{
|
|
var parent = new GameObject("Geo_Tile_Addressables");
|
|
tilesParent = parent.transform;
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
if (player == null && Camera.main != null)
|
|
player = Camera.main.transform;
|
|
|
|
StartCoroutine(Initialize());
|
|
}
|
|
|
|
private IEnumerator Initialize()
|
|
{
|
|
var buildTargetFolder = string.IsNullOrWhiteSpace(buildTargetFolderOverride)
|
|
? GetBuildTargetFolderName()
|
|
: buildTargetFolderOverride;
|
|
|
|
var basePath = Path.Combine(Application.persistentDataPath, tileBundleFolderName, buildTargetFolder);
|
|
var manifestPath = Path.Combine(basePath, manifestFileName);
|
|
|
|
Log($"Initializing loader. BasePath={basePath}");
|
|
Log($"ManifestPath={manifestPath}");
|
|
|
|
if (!File.Exists(manifestPath))
|
|
{
|
|
Debug.LogError($"[GeoTileAddressablesLoader] Manifest not found: {manifestPath}");
|
|
yield break;
|
|
}
|
|
|
|
manifest = JsonUtility.FromJson<TileManifest>(File.ReadAllText(manifestPath));
|
|
if (manifest == null || manifest.tiles == null || manifest.tiles.Length == 0)
|
|
{
|
|
Debug.LogError("[GeoTileAddressablesLoader] Manifest is empty or invalid.");
|
|
yield break;
|
|
}
|
|
|
|
tiles.Clear();
|
|
foreach (var tile in manifest.tiles)
|
|
{
|
|
var key = !string.IsNullOrWhiteSpace(tile.tileKey) ? tile.tileKey : tile.tileId;
|
|
if (!string.IsNullOrWhiteSpace(key))
|
|
tiles[key] = tile;
|
|
}
|
|
|
|
LoadBuildingManifest(basePath);
|
|
BuildBuildingBlocks();
|
|
|
|
Log($"Manifest loaded. Tiles={tiles.Count} CatalogFile={manifest.catalogFile}");
|
|
|
|
var catalogPath = Path.Combine(basePath, manifest.catalogFile);
|
|
if (!File.Exists(catalogPath))
|
|
{
|
|
Debug.LogError($"[GeoTileAddressablesLoader] Catalog not found: {catalogPath}");
|
|
yield break;
|
|
}
|
|
|
|
Log($"Loading catalog: {catalogPath}");
|
|
var handle = Addressables.LoadContentCatalogAsync(ToFileUri(catalogPath), true);
|
|
yield return handle;
|
|
|
|
if (handle.Status != AsyncOperationStatus.Succeeded)
|
|
{
|
|
Debug.LogError($"[GeoTileAddressablesLoader] Catalog load failed: {handle.OperationException}");
|
|
yield break;
|
|
}
|
|
|
|
Log("Catalog loaded successfully.");
|
|
initialized = true;
|
|
nextUpdateTime = Time.time;
|
|
}
|
|
|
|
private void LoadBuildingManifest(string basePath)
|
|
{
|
|
buildingManifest = null;
|
|
buildingTiles.Clear();
|
|
|
|
if (!loadBuildingsFor2kmBlocks || string.IsNullOrWhiteSpace(buildingManifestFileName))
|
|
return;
|
|
|
|
var path = Path.Combine(basePath, buildingManifestFileName);
|
|
if (!File.Exists(path))
|
|
{
|
|
Log($"Building manifest not found: {path}");
|
|
return;
|
|
}
|
|
|
|
buildingManifest = JsonUtility.FromJson<TileManifest>(File.ReadAllText(path));
|
|
if (buildingManifest == null || buildingManifest.tiles == null || buildingManifest.tiles.Length == 0)
|
|
{
|
|
Log("Building manifest is empty or invalid.");
|
|
return;
|
|
}
|
|
|
|
foreach (var tile in buildingManifest.tiles)
|
|
{
|
|
var key = !string.IsNullOrWhiteSpace(tile.tileKey) ? tile.tileKey : tile.tileId;
|
|
if (!string.IsNullOrWhiteSpace(key))
|
|
buildingTiles[key] = tile;
|
|
}
|
|
|
|
Log($"Building manifest loaded. BuildingTiles={buildingTiles.Count}");
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!initialized || player == null)
|
|
return;
|
|
|
|
if (Time.time < nextUpdateTime)
|
|
return;
|
|
|
|
nextUpdateTime = Time.time + updateInterval;
|
|
|
|
UpdateTileSet();
|
|
ProcessQueue();
|
|
}
|
|
|
|
private void UpdateTileSet()
|
|
{
|
|
var playerPos = player.position;
|
|
var tileSize = manifest.tileSizeMeters;
|
|
var wantedTiles = new HashSet<string>();
|
|
HashSet<string> wantedBlocks = (loadBuildingsFor2kmBlocks && buildingTiles.Count > 0)
|
|
? new HashSet<string>()
|
|
: null;
|
|
|
|
foreach (var kvp in tiles)
|
|
{
|
|
var tileKey = kvp.Key;
|
|
var tile = kvp.Value;
|
|
var tileCenter = new Vector3(
|
|
tile.offsetX + tileSize * 0.5f,
|
|
tile.baseY,
|
|
tile.offsetZ + tileSize * 0.5f);
|
|
var distance = Vector2.Distance(
|
|
new Vector2(playerPos.x, playerPos.z),
|
|
new Vector2(tileCenter.x, tileCenter.z));
|
|
|
|
bool withinLoad = distance <= loadRadiusMeters;
|
|
bool withinKeep = distance <= unloadRadiusMeters;
|
|
|
|
if (withinLoad || (withinKeep && loaded.ContainsKey(tileKey)))
|
|
wantedTiles.Add(tileKey);
|
|
|
|
if (wantedBlocks != null && tileBlockKey.TryGetValue(tileKey, out var blockKey))
|
|
{
|
|
if (withinLoad)
|
|
wantedBlocks.Add(blockKey);
|
|
else if (withinKeep && blockBuildingKey.TryGetValue(blockKey, out var buildingKey) && buildingLoaded.ContainsKey(buildingKey))
|
|
wantedBlocks.Add(blockKey);
|
|
}
|
|
}
|
|
|
|
foreach (var tileKey in wantedTiles)
|
|
EnqueueTileLoad(tileKey);
|
|
|
|
if (loaded.Count == 0)
|
|
{
|
|
if (wantedBlocks == null)
|
|
return;
|
|
}
|
|
|
|
var toUnload = new List<string>();
|
|
foreach (var kvp in loaded)
|
|
{
|
|
if (!wantedTiles.Contains(kvp.Key))
|
|
toUnload.Add(kvp.Key);
|
|
}
|
|
|
|
for (int i = 0; i < toUnload.Count; i++)
|
|
UnloadTile(toUnload[i]);
|
|
|
|
if (wantedBlocks == null)
|
|
return;
|
|
|
|
var wantedBuildingKeys = new HashSet<string>();
|
|
foreach (var blockKey in wantedBlocks)
|
|
{
|
|
if (blockBuildingKey.TryGetValue(blockKey, out var buildingKey))
|
|
wantedBuildingKeys.Add(buildingKey);
|
|
}
|
|
|
|
foreach (var buildingKey in wantedBuildingKeys)
|
|
EnqueueBuildingLoad(buildingKey);
|
|
|
|
if (buildingLoaded.Count == 0)
|
|
return;
|
|
|
|
var toUnloadBuildings = new List<string>();
|
|
foreach (var kvp in buildingLoaded)
|
|
{
|
|
if (!wantedBuildingKeys.Contains(kvp.Key))
|
|
toUnloadBuildings.Add(kvp.Key);
|
|
}
|
|
|
|
for (int i = 0; i < toUnloadBuildings.Count; i++)
|
|
UnloadBuilding(toUnloadBuildings[i]);
|
|
}
|
|
|
|
private void EnqueueTileLoad(string tileKey)
|
|
{
|
|
if (loaded.ContainsKey(tileKey) || loading.Contains(tileKey) || queued.Contains(tileKey))
|
|
return;
|
|
|
|
loadQueue.Enqueue(tileKey);
|
|
queued.Add(tileKey);
|
|
}
|
|
|
|
private void EnqueueBuildingLoad(string buildingKey)
|
|
{
|
|
if (buildingLoaded.ContainsKey(buildingKey) || buildingLoading.Contains(buildingKey) || buildingQueued.Contains(buildingKey))
|
|
return;
|
|
|
|
buildingLoadQueue.Enqueue(buildingKey);
|
|
buildingQueued.Add(buildingKey);
|
|
}
|
|
|
|
private void ProcessQueue()
|
|
{
|
|
bool preferTiles = true;
|
|
while (loadQueue.Count > 0 || buildingLoadQueue.Count > 0)
|
|
{
|
|
int inFlight = loading.Count + buildingLoading.Count;
|
|
if (inFlight >= maxConcurrentLoads)
|
|
return;
|
|
|
|
if ((preferTiles && loadQueue.Count > 0) || buildingLoadQueue.Count == 0)
|
|
{
|
|
var tileKey = loadQueue.Dequeue();
|
|
queued.Remove(tileKey);
|
|
StartLoad(tileKey);
|
|
}
|
|
else
|
|
{
|
|
var buildingKey = buildingLoadQueue.Dequeue();
|
|
buildingQueued.Remove(buildingKey);
|
|
StartBuildingLoad(buildingKey);
|
|
}
|
|
|
|
preferTiles = !preferTiles;
|
|
}
|
|
}
|
|
|
|
private void StartLoad(string tileKey)
|
|
{
|
|
if (!tiles.TryGetValue(tileKey, out var tile))
|
|
return;
|
|
|
|
loading.Add(tileKey);
|
|
Log($"Loading tile {tileKey}...");
|
|
|
|
var handle = Addressables.InstantiateAsync(tileKey, tilesParent);
|
|
handle.Completed += op =>
|
|
{
|
|
loading.Remove(tileKey);
|
|
|
|
if (op.Status != AsyncOperationStatus.Succeeded)
|
|
{
|
|
Debug.LogError($"[GeoTileAddressablesLoader] Load failed for {tileKey}: {op.OperationException}");
|
|
return;
|
|
}
|
|
|
|
var instance = op.Result;
|
|
instance.name = tileKey;
|
|
instance.transform.position = new Vector3(tile.offsetX, tile.baseY, tile.offsetZ);
|
|
loaded[tileKey] = instance;
|
|
Log($"Loaded tile {tileKey}. LoadedCount={loaded.Count}");
|
|
};
|
|
}
|
|
|
|
private void StartBuildingLoad(string buildingKey)
|
|
{
|
|
if (!buildingTiles.TryGetValue(buildingKey, out var tile))
|
|
return;
|
|
|
|
buildingLoading.Add(buildingKey);
|
|
Log($"Loading buildings {buildingKey}...");
|
|
|
|
var handle = Addressables.InstantiateAsync(buildingKey, tilesParent);
|
|
handle.Completed += op =>
|
|
{
|
|
buildingLoading.Remove(buildingKey);
|
|
|
|
if (op.Status != AsyncOperationStatus.Succeeded)
|
|
{
|
|
Debug.LogError($"[GeoTileAddressablesLoader] Building load failed for {buildingKey}: {op.OperationException}");
|
|
return;
|
|
}
|
|
|
|
var instance = op.Result;
|
|
instance.name = buildingKey;
|
|
instance.transform.position = new Vector3(tile.offsetX, tile.baseY, tile.offsetZ);
|
|
buildingLoaded[buildingKey] = instance;
|
|
Log($"Loaded buildings {buildingKey}. LoadedCount={buildingLoaded.Count}");
|
|
};
|
|
}
|
|
|
|
private void UnloadTile(string tileKey)
|
|
{
|
|
if (!loaded.TryGetValue(tileKey, out var instance))
|
|
return;
|
|
|
|
Addressables.ReleaseInstance(instance);
|
|
loaded.Remove(tileKey);
|
|
Log($"Unloaded tile {tileKey}. LoadedCount={loaded.Count}");
|
|
}
|
|
|
|
private void UnloadBuilding(string buildingKey)
|
|
{
|
|
if (!buildingLoaded.TryGetValue(buildingKey, out var instance))
|
|
return;
|
|
|
|
Addressables.ReleaseInstance(instance);
|
|
buildingLoaded.Remove(buildingKey);
|
|
Log($"Unloaded buildings {buildingKey}. LoadedCount={buildingLoaded.Count}");
|
|
}
|
|
|
|
private void BuildBuildingBlocks()
|
|
{
|
|
tileBlockKey.Clear();
|
|
blockBuildingKey.Clear();
|
|
|
|
if (!loadBuildingsFor2kmBlocks)
|
|
return;
|
|
|
|
int blockSize = Math.Max(1, buildingBlockSizeInTiles);
|
|
foreach (var kvp in tiles)
|
|
{
|
|
if (!TryGetTileXY(kvp.Value, out int x, out int y))
|
|
continue;
|
|
|
|
int blockX = x - (x % blockSize);
|
|
int blockY = y - (y % blockSize);
|
|
string blockKey = $"{blockX}_{blockY}";
|
|
tileBlockKey[kvp.Key] = blockKey;
|
|
}
|
|
|
|
if (buildingTiles.Count == 0)
|
|
return;
|
|
|
|
foreach (var kvp in buildingTiles)
|
|
{
|
|
if (!TryGetTileXY(kvp.Value, out int x, out int y))
|
|
continue;
|
|
|
|
int blockX = x - (x % blockSize);
|
|
int blockY = y - (y % blockSize);
|
|
string blockKey = $"{blockX}_{blockY}";
|
|
blockBuildingKey[blockKey] = kvp.Key;
|
|
}
|
|
}
|
|
|
|
private static bool TryGetTileXY(TileEntry tile, out int x, out int y)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(tile.tileKey) && TryParseTileKey(tile.tileKey, out x, out y))
|
|
return true;
|
|
|
|
return TryParseTileId(tile.tileId, out x, out y);
|
|
}
|
|
|
|
private static bool TryParseTileKey(string tileKey, out int x, out int y)
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
if (string.IsNullOrWhiteSpace(tileKey))
|
|
return false;
|
|
|
|
var parts = tileKey.Split('_');
|
|
if (parts.Length != 2)
|
|
return false;
|
|
|
|
return int.TryParse(parts[0], out x) && int.TryParse(parts[1], out y);
|
|
}
|
|
|
|
private static bool TryParseTileId(string tileId, out int x, out int y)
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
if (string.IsNullOrWhiteSpace(tileId))
|
|
return false;
|
|
|
|
var parts = tileId.Split('_');
|
|
var coords = new List<int>();
|
|
for (int i = 0; i < parts.Length; i++)
|
|
{
|
|
var part = parts[i];
|
|
if (part.Length < 3)
|
|
continue;
|
|
|
|
bool allDigits = true;
|
|
for (int j = 0; j < part.Length; j++)
|
|
{
|
|
if (!char.IsDigit(part[j]))
|
|
{
|
|
allDigits = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!allDigits)
|
|
continue;
|
|
|
|
if (int.TryParse(part, out int value))
|
|
coords.Add(value);
|
|
}
|
|
|
|
if (coords.Count < 2)
|
|
return false;
|
|
|
|
x = coords[coords.Count - 2];
|
|
y = coords[coords.Count - 1];
|
|
return true;
|
|
}
|
|
|
|
private static string GetBuildTargetFolderName()
|
|
{
|
|
switch (Application.platform)
|
|
{
|
|
case RuntimePlatform.Android:
|
|
return "Android";
|
|
case RuntimePlatform.WindowsPlayer:
|
|
case RuntimePlatform.WindowsEditor:
|
|
return "StandaloneWindows64";
|
|
case RuntimePlatform.LinuxPlayer:
|
|
case RuntimePlatform.LinuxEditor:
|
|
return "StandaloneLinux64";
|
|
case RuntimePlatform.OSXPlayer:
|
|
case RuntimePlatform.OSXEditor:
|
|
return "StandaloneOSX";
|
|
default:
|
|
return "Android";
|
|
}
|
|
}
|
|
|
|
private static string ToFileUri(string path)
|
|
{
|
|
var normalized = path.Replace("\\", "/");
|
|
return normalized.StartsWith("file://", StringComparison.OrdinalIgnoreCase)
|
|
? normalized
|
|
: "file://" + normalized;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
foreach (var instance in loaded.Values)
|
|
Addressables.ReleaseInstance(instance);
|
|
|
|
loaded.Clear();
|
|
loading.Clear();
|
|
queued.Clear();
|
|
loadQueue.Clear();
|
|
|
|
foreach (var instance in buildingLoaded.Values)
|
|
Addressables.ReleaseInstance(instance);
|
|
|
|
buildingLoaded.Clear();
|
|
buildingLoading.Clear();
|
|
buildingQueued.Clear();
|
|
buildingLoadQueue.Clear();
|
|
}
|
|
|
|
private void Log(string message)
|
|
{
|
|
if (verboseLogging)
|
|
Debug.Log($"[GeoTileAddressablesLoader] {message}");
|
|
}
|
|
}
|