958 lines
41 KiB
C#
958 lines
41 KiB
C#
// Assets/Editor/GeoTileImporter.cs
|
|
// Robust terrain tile importer for Unity (URP or Built-in).
|
|
// - Parses CSV header -> column name mapping (order-independent)
|
|
// - Validates required columns exist
|
|
// - Imports 16-bit PNG heightmaps (tries Single Channel R16 + ushort pixel read; falls back safely)
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
public class GeoTileImporter : EditorWindow
|
|
{
|
|
private string tilesCsvPath = "Assets/GeoData/tile_index.csv";
|
|
private string heightmapsDir = "Assets/GeoData/height_png16";
|
|
private string orthoDir = "Assets/GeoData/ortho_jpg";
|
|
private string buildingsDir = "Assets/GeoData/buildings_tiles";
|
|
private string buildingsEnhancedDir = "Assets/GeoData/buildings_enhanced";
|
|
private string treesDir = "Assets/GeoData/trees_tiles";
|
|
private string treeProxyPath = "Assets/GeoData/tree_proxies.glb";
|
|
private string furnitureDir = "Assets/GeoData/street_furniture";
|
|
private string enhancedTreesDir = "Assets/GeoData/trees_enhanced";
|
|
|
|
private float tileSizeMeters = 1000f;
|
|
private int heightmapResolution = 1025;
|
|
|
|
private string parentName = "Geo_Terrain_Tiles";
|
|
private string buildingsParentName = "Geo_Buildings";
|
|
private string treesParentName = "Geo_Trees";
|
|
private string furnitureParentName = "Geo_Furniture";
|
|
private bool deleteExisting = false;
|
|
private bool applyOrthoTextures = true;
|
|
private bool importBuildings = true;
|
|
private bool useEnhancedBuildings = false;
|
|
private bool importTrees = true;
|
|
private bool importFurniture = false;
|
|
private bool deleteExistingBuildings = false;
|
|
private bool deleteExistingTrees = false;
|
|
private bool deleteExistingFurniture = false;
|
|
private bool importEnhancedTrees = false;
|
|
private bool deleteExistingEnhancedTrees = false;
|
|
private string enhancedTreesParentName = "Geo_Trees_Enhanced";
|
|
|
|
// Prefabs for trees and furniture (assign in editor)
|
|
private GameObject treePrefab;
|
|
private GameObject lampPrefab;
|
|
private GameObject benchPrefab;
|
|
private GameObject signPrefab;
|
|
private GameObject bollardPrefab;
|
|
private GameObject defaultFurniturePrefab; // Fallback for unknown types
|
|
|
|
[MenuItem("Tools/Geo Tiles/Import Terrain Tiles (PNG16)")]
|
|
public static void ShowWindow()
|
|
{
|
|
var win = GetWindow<GeoTileImporter>("Geo Tile Importer");
|
|
win.minSize = new Vector2(620, 300);
|
|
}
|
|
|
|
private void OnGUI()
|
|
{
|
|
GUILayout.Label("Inputs", EditorStyles.boldLabel);
|
|
tilesCsvPath = EditorGUILayout.TextField("tile_index.csv", tilesCsvPath);
|
|
heightmapsDir = EditorGUILayout.TextField("height_png16 dir", heightmapsDir);
|
|
orthoDir = EditorGUILayout.TextField("ortho_jpg dir", orthoDir);
|
|
buildingsDir = EditorGUILayout.TextField("buildings_glb dir", buildingsDir);
|
|
treesDir = EditorGUILayout.TextField("trees_glb dir", treesDir);
|
|
treeProxyPath = EditorGUILayout.TextField("tree_proxies.glb", treeProxyPath);
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.Label("Terrain", EditorStyles.boldLabel);
|
|
tileSizeMeters = EditorGUILayout.FloatField("Tile size (m)", tileSizeMeters);
|
|
heightmapResolution = EditorGUILayout.IntField("Heightmap resolution", heightmapResolution);
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.Label("Scene", EditorStyles.boldLabel);
|
|
parentName = EditorGUILayout.TextField("Parent object name", parentName);
|
|
deleteExisting = EditorGUILayout.ToggleLeft("Delete existing terrains under parent", deleteExisting);
|
|
applyOrthoTextures = EditorGUILayout.ToggleLeft("Apply ortho texture per tile", applyOrthoTextures);
|
|
buildingsParentName = EditorGUILayout.TextField("Buildings parent name", buildingsParentName);
|
|
buildingsEnhancedDir = EditorGUILayout.TextField("Buildings enhanced dir", buildingsEnhancedDir);
|
|
deleteExistingBuildings = EditorGUILayout.ToggleLeft("Delete existing buildings under parent", deleteExistingBuildings);
|
|
importBuildings = EditorGUILayout.ToggleLeft("Import buildings (GLB per tile)", importBuildings);
|
|
useEnhancedBuildings = EditorGUILayout.ToggleLeft("Use enhanced buildings (from buildings_enhanced/)", useEnhancedBuildings);
|
|
|
|
GUILayout.Space(5);
|
|
treesParentName = EditorGUILayout.TextField("Trees parent name", treesParentName);
|
|
deleteExistingTrees = EditorGUILayout.ToggleLeft("Delete existing trees under parent", deleteExistingTrees);
|
|
importTrees = EditorGUILayout.ToggleLeft("Import trees (GLB chunks per tile)", importTrees);
|
|
|
|
GUILayout.Space(5);
|
|
furnitureParentName = EditorGUILayout.TextField("Furniture parent name", furnitureParentName);
|
|
furnitureDir = EditorGUILayout.TextField("Furniture CSV dir", furnitureDir);
|
|
deleteExistingFurniture = EditorGUILayout.ToggleLeft("Delete existing furniture under parent", deleteExistingFurniture);
|
|
importFurniture = EditorGUILayout.ToggleLeft("Import street furniture (from CSV)", importFurniture);
|
|
|
|
GUILayout.Space(5);
|
|
enhancedTreesParentName = EditorGUILayout.TextField("Enhanced trees parent", enhancedTreesParentName);
|
|
enhancedTreesDir = EditorGUILayout.TextField("Enhanced trees CSV dir", enhancedTreesDir);
|
|
deleteExistingEnhancedTrees = EditorGUILayout.ToggleLeft("Delete existing enhanced trees", deleteExistingEnhancedTrees);
|
|
importEnhancedTrees = EditorGUILayout.ToggleLeft("Import enhanced trees (CSV with canopy colors)", importEnhancedTrees);
|
|
|
|
GUILayout.Space(10);
|
|
GUILayout.Label("Prefabs (optional)", EditorStyles.boldLabel);
|
|
treePrefab = (GameObject)EditorGUILayout.ObjectField("Tree Prefab", treePrefab, typeof(GameObject), false);
|
|
lampPrefab = (GameObject)EditorGUILayout.ObjectField("Lamp Prefab", lampPrefab, typeof(GameObject), false);
|
|
benchPrefab = (GameObject)EditorGUILayout.ObjectField("Bench Prefab", benchPrefab, typeof(GameObject), false);
|
|
signPrefab = (GameObject)EditorGUILayout.ObjectField("Sign Prefab", signPrefab, typeof(GameObject), false);
|
|
bollardPrefab = (GameObject)EditorGUILayout.ObjectField("Bollard Prefab", bollardPrefab, typeof(GameObject), false);
|
|
defaultFurniturePrefab = (GameObject)EditorGUILayout.ObjectField("Default Furniture Prefab", defaultFurniturePrefab, typeof(GameObject), false);
|
|
|
|
GUILayout.Space(12);
|
|
if (GUILayout.Button("Import / Rebuild"))
|
|
ImportTiles();
|
|
|
|
EditorGUILayout.HelpBox(
|
|
"Creates one Unity Terrain per CSV row and positions tiles on a meter grid.\n" +
|
|
"Absolute elevation mapping: Terrain Y = global_min, Terrain height = (global_max - global_min).\n" +
|
|
"CSV is header-driven (order-independent). Optionally applies ortho JPGs and instantiates buildings/trees GLBs.",
|
|
MessageType.Info);
|
|
}
|
|
|
|
private static void EnsureHeightmapImportSettings(string assetPath)
|
|
{
|
|
var ti = (TextureImporter)AssetImporter.GetAtPath(assetPath);
|
|
if (ti == null) return;
|
|
|
|
bool changed = false;
|
|
|
|
if (!ti.isReadable) { ti.isReadable = true; changed = true; }
|
|
if (ti.sRGBTexture) { ti.sRGBTexture = false; changed = true; }
|
|
|
|
if (ti.textureCompression != TextureImporterCompression.Uncompressed)
|
|
{
|
|
ti.textureCompression = TextureImporterCompression.Uncompressed;
|
|
changed = true;
|
|
}
|
|
|
|
if (ti.npotScale != TextureImporterNPOTScale.None)
|
|
{
|
|
ti.npotScale = TextureImporterNPOTScale.None; // keep 1025x1025
|
|
changed = true;
|
|
}
|
|
|
|
if (ti.textureType != TextureImporterType.SingleChannel)
|
|
{
|
|
ti.textureType = TextureImporterType.SingleChannel;
|
|
changed = true;
|
|
}
|
|
|
|
var ps = ti.GetDefaultPlatformTextureSettings();
|
|
if (ps.format != TextureImporterFormat.R16)
|
|
{
|
|
ps.format = TextureImporterFormat.R16;
|
|
ti.SetPlatformTextureSettings(ps);
|
|
changed = true;
|
|
}
|
|
|
|
changed |= EnsurePlatformR16(ti, "Standalone");
|
|
changed |= EnsurePlatformR16(ti, "Android");
|
|
changed |= EnsurePlatformR16(ti, "iPhone");
|
|
|
|
if (changed) ti.SaveAndReimport();
|
|
}
|
|
|
|
private static bool EnsurePlatformR16(TextureImporter ti, string platform)
|
|
{
|
|
var ps = ti.GetPlatformTextureSettings(platform);
|
|
|
|
bool changed = false;
|
|
if (ps.name != platform)
|
|
{
|
|
ps = new TextureImporterPlatformSettings
|
|
{
|
|
name = platform,
|
|
overridden = true,
|
|
format = TextureImporterFormat.R16,
|
|
textureCompression = TextureImporterCompression.Uncompressed,
|
|
};
|
|
ti.SetPlatformTextureSettings(ps);
|
|
return true;
|
|
}
|
|
|
|
if (!ps.overridden) { ps.overridden = true; changed = true; }
|
|
if (ps.format != TextureImporterFormat.R16) { ps.format = TextureImporterFormat.R16; changed = true; }
|
|
if (ps.textureCompression != TextureImporterCompression.Uncompressed)
|
|
{
|
|
ps.textureCompression = TextureImporterCompression.Uncompressed;
|
|
changed = true;
|
|
}
|
|
|
|
if (changed) ti.SetPlatformTextureSettings(ps);
|
|
return changed;
|
|
}
|
|
|
|
private static string NormalizeHeader(string s)
|
|
=> (s ?? "").Trim().ToLowerInvariant();
|
|
|
|
private static void EnsureOrthoImportSettings(string assetPath)
|
|
{
|
|
var ti = (TextureImporter)AssetImporter.GetAtPath(assetPath);
|
|
if (ti == null) return;
|
|
|
|
bool changed = false;
|
|
if (!ti.isReadable) { ti.isReadable = true; changed = true; }
|
|
if (!ti.sRGBTexture) { ti.sRGBTexture = true; changed = true; }
|
|
if (ti.npotScale != TextureImporterNPOTScale.None) { ti.npotScale = TextureImporterNPOTScale.None; changed = true; }
|
|
if (ti.wrapMode != TextureWrapMode.Clamp) { ti.wrapMode = TextureWrapMode.Clamp; changed = true; }
|
|
if (ti.textureCompression != TextureImporterCompression.Uncompressed)
|
|
{
|
|
ti.textureCompression = TextureImporterCompression.Uncompressed;
|
|
changed = true;
|
|
}
|
|
|
|
if (changed) ti.SaveAndReimport();
|
|
}
|
|
|
|
private static Dictionary<string, int> BuildHeaderMap(string headerLine)
|
|
{
|
|
var map = new Dictionary<string, int>();
|
|
var cols = headerLine.Split(',');
|
|
for (int i = 0; i < cols.Length; i++)
|
|
{
|
|
var key = NormalizeHeader(cols[i]);
|
|
if (string.IsNullOrEmpty(key)) continue;
|
|
if (!map.ContainsKey(key))
|
|
map[key] = i;
|
|
}
|
|
return map;
|
|
}
|
|
|
|
private static bool HasAll(Dictionary<string, int> map, params string[] required)
|
|
{
|
|
foreach (var r in required)
|
|
if (!map.ContainsKey(NormalizeHeader(r)))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
private void ImportTiles()
|
|
{
|
|
Debug.Log($"[GeoTileImporter] START\n csv={tilesCsvPath}\n pngDir={heightmapsDir}");
|
|
|
|
if (!File.Exists(tilesCsvPath))
|
|
{
|
|
Debug.LogError($"[GeoTileImporter] CSV not found: {tilesCsvPath}");
|
|
return;
|
|
}
|
|
if (!Directory.Exists(heightmapsDir))
|
|
{
|
|
Debug.LogError($"[GeoTileImporter] Heightmap dir not found: {heightmapsDir}");
|
|
return;
|
|
}
|
|
if (applyOrthoTextures && !Directory.Exists(orthoDir))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Ortho dir not found: {orthoDir} (textures will be skipped).");
|
|
applyOrthoTextures = false;
|
|
}
|
|
|
|
var parent = GameObject.Find(parentName);
|
|
if (parent == null) parent = new GameObject(parentName);
|
|
|
|
if (deleteExisting)
|
|
{
|
|
for (int i = parent.transform.childCount - 1; i >= 0; i--)
|
|
DestroyImmediate(parent.transform.GetChild(i).gameObject);
|
|
}
|
|
|
|
var ci = CultureInfo.InvariantCulture;
|
|
var lines = File.ReadAllLines(tilesCsvPath);
|
|
|
|
Debug.Log($"[GeoTileImporter] Read {lines.Length} lines.");
|
|
if (lines.Length < 2)
|
|
{
|
|
Debug.LogError("[GeoTileImporter] CSV has no data rows (need header + at least 1 row).");
|
|
return;
|
|
}
|
|
|
|
var headerLine = lines[0].Trim();
|
|
var headerMap = BuildHeaderMap(headerLine);
|
|
Debug.Log($"[GeoTileImporter] Header: {headerLine}");
|
|
Debug.Log($"[GeoTileImporter] Header columns mapped: {string.Join(", ", headerMap.Keys)}");
|
|
|
|
// Required columns (order-independent)
|
|
string[] required = { "tile_id", "xmin", "ymin", "global_min", "global_max", "out_res" };
|
|
if (!HasAll(headerMap, required))
|
|
{
|
|
Debug.LogError("[GeoTileImporter] CSV missing required columns. Required: " +
|
|
string.Join(", ", required) +
|
|
"\nFound: " + string.Join(", ", headerMap.Keys));
|
|
return;
|
|
}
|
|
|
|
int IDX_TILE = headerMap["tile_id"];
|
|
int IDX_XMIN = headerMap["xmin"];
|
|
int IDX_YMIN = headerMap["ymin"];
|
|
int IDX_GMIN = headerMap["global_min"];
|
|
int IDX_GMAX = headerMap["global_max"];
|
|
int IDX_RES = headerMap["out_res"];
|
|
|
|
// Compute origin from min xmin/ymin
|
|
double originX = double.PositiveInfinity;
|
|
double originY = double.PositiveInfinity;
|
|
|
|
int validRowsForOrigin = 0;
|
|
for (int i = 1; i < lines.Length; i++)
|
|
{
|
|
var line = lines[i].Trim();
|
|
if (string.IsNullOrWhiteSpace(line)) continue;
|
|
|
|
var parts = line.Split(',');
|
|
// Robust: just ensure indices exist in this row
|
|
int needMaxIndex = Math.Max(Math.Max(Math.Max(Math.Max(IDX_TILE, IDX_XMIN), IDX_YMIN), IDX_GMIN), Math.Max(IDX_GMAX, IDX_RES));
|
|
if (parts.Length <= needMaxIndex)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Origin scan: skipping line {i + 1} (too few columns: {parts.Length}). Line: '{line}'");
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
double xmin = double.Parse(parts[IDX_XMIN], ci);
|
|
double ymin = double.Parse(parts[IDX_YMIN], ci);
|
|
originX = Math.Min(originX, xmin);
|
|
originY = Math.Min(originY, ymin);
|
|
validRowsForOrigin++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Origin scan parse failed line {i + 1}: '{line}'\n{e.Message}");
|
|
}
|
|
}
|
|
|
|
if (validRowsForOrigin == 0 || double.IsInfinity(originX) || double.IsInfinity(originY))
|
|
{
|
|
Debug.LogError("[GeoTileImporter] Could not compute origin (no valid rows parsed). Check CSV numeric format.");
|
|
return;
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Origin: ({originX}, {originY}) from {validRowsForOrigin} valid rows.");
|
|
|
|
int imported = 0, skipped = 0;
|
|
int importedTextures = 0;
|
|
var placements = new List<(string tileId, float ux, float uz, float gmin)>();
|
|
|
|
for (int i = 1; i < lines.Length; i++)
|
|
{
|
|
var line = lines[i].Trim();
|
|
if (string.IsNullOrWhiteSpace(line)) continue;
|
|
|
|
var parts = line.Split(',');
|
|
int needMaxIndex = Math.Max(Math.Max(Math.Max(Math.Max(IDX_TILE, IDX_XMIN), IDX_YMIN), IDX_GMIN), Math.Max(IDX_GMAX, IDX_RES));
|
|
if (parts.Length <= needMaxIndex)
|
|
{
|
|
skipped++;
|
|
Debug.LogWarning($"[GeoTileImporter] Skipping line {i + 1} (too few columns: {parts.Length}). Line: '{line}'");
|
|
continue;
|
|
}
|
|
|
|
string tileId = parts[IDX_TILE].Trim();
|
|
|
|
double xmin, ymin, gmin, gmax;
|
|
int outRes;
|
|
try
|
|
{
|
|
xmin = double.Parse(parts[IDX_XMIN], ci);
|
|
ymin = double.Parse(parts[IDX_YMIN], ci);
|
|
gmin = double.Parse(parts[IDX_GMIN], ci);
|
|
gmax = double.Parse(parts[IDX_GMAX], ci);
|
|
outRes = int.Parse(parts[IDX_RES], ci);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
skipped++;
|
|
Debug.LogWarning($"[GeoTileImporter] Parse failed line {i + 1} tile '{tileId}': {e.Message}\nLine: '{line}'");
|
|
continue;
|
|
}
|
|
|
|
if (outRes != heightmapResolution)
|
|
Debug.LogWarning($"[GeoTileImporter] Tile {tileId}: out_res={outRes} but importer expects {heightmapResolution}.");
|
|
|
|
float heightRange = (float)(gmax - gmin);
|
|
if (heightRange <= 0.0001f)
|
|
{
|
|
skipped++;
|
|
Debug.LogWarning($"[GeoTileImporter] Tile {tileId}: invalid height range (global_max <= global_min). Skipping.");
|
|
continue;
|
|
}
|
|
|
|
string pngPath = Path.Combine(heightmapsDir, $"{tileId}.png").Replace("\\", "/");
|
|
if (!File.Exists(pngPath))
|
|
{
|
|
skipped++;
|
|
Debug.LogError($"[GeoTileImporter] Missing PNG for {tileId}: {pngPath}");
|
|
continue;
|
|
}
|
|
|
|
EnsureHeightmapImportSettings(pngPath);
|
|
|
|
var tex = AssetDatabase.LoadAssetAtPath<Texture2D>(pngPath);
|
|
if (tex == null)
|
|
{
|
|
skipped++;
|
|
Debug.LogError($"[GeoTileImporter] Could not load Texture2D asset: {pngPath}");
|
|
continue;
|
|
}
|
|
|
|
if (tex.width != heightmapResolution || tex.height != heightmapResolution)
|
|
Debug.LogWarning($"[GeoTileImporter] Tile {tileId}: PNG {tex.width}x{tex.height}, expected {heightmapResolution}x{heightmapResolution}.");
|
|
|
|
var terrainData = new TerrainData
|
|
{
|
|
heightmapResolution = heightmapResolution,
|
|
size = new Vector3(tileSizeMeters, heightRange, tileSizeMeters),
|
|
};
|
|
|
|
int w = tex.width;
|
|
int h = tex.height;
|
|
var heights = new float[h, w];
|
|
|
|
bool usedU16 = false;
|
|
try
|
|
{
|
|
var raw = tex.GetPixelData<ushort>(0);
|
|
if (raw.Length == w * h)
|
|
{
|
|
for (int y = 0; y < h; y++)
|
|
for (int x = 0; x < w; x++)
|
|
heights[y, x] = raw[y * w + x] / 65535f;
|
|
usedU16 = true;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// fallback below
|
|
}
|
|
|
|
if (!usedU16)
|
|
{
|
|
var pixels = tex.GetPixels();
|
|
for (int y = 0; y < h; y++)
|
|
for (int x = 0; x < w; x++)
|
|
heights[y, x] = pixels[y * w + x].r;
|
|
}
|
|
|
|
terrainData.SetHeights(0, 0, heights);
|
|
|
|
var go = Terrain.CreateTerrainGameObject(terrainData);
|
|
go.name = tileId;
|
|
go.transform.parent = parent.transform;
|
|
|
|
float ux = (float)(xmin - originX);
|
|
float uz = (float)(ymin - originY);
|
|
go.transform.position = new Vector3(ux, (float)gmin, uz);
|
|
|
|
var terrain = go.GetComponent<Terrain>();
|
|
terrain.drawInstanced = true;
|
|
|
|
// Optional ortho texture application
|
|
if (applyOrthoTextures)
|
|
{
|
|
string orthoPath = Path.Combine(orthoDir, $"{tileId}.jpg").Replace("\\", "/");
|
|
if (File.Exists(orthoPath))
|
|
{
|
|
EnsureOrthoImportSettings(orthoPath);
|
|
var orthoTex = AssetDatabase.LoadAssetAtPath<Texture2D>(orthoPath);
|
|
if (orthoTex == null)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Could not load ortho texture for {tileId}: {orthoPath}");
|
|
}
|
|
else
|
|
{
|
|
var layer = new TerrainLayer
|
|
{
|
|
diffuseTexture = orthoTex,
|
|
tileSize = new Vector2(tileSizeMeters, tileSizeMeters),
|
|
tileOffset = Vector2.zero
|
|
};
|
|
terrainData.terrainLayers = new[] { layer };
|
|
terrainData.alphamapResolution = 16;
|
|
var alpha = new float[terrainData.alphamapHeight, terrainData.alphamapWidth, 1];
|
|
for (int ay = 0; ay < terrainData.alphamapHeight; ay++)
|
|
for (int ax = 0; ax < terrainData.alphamapWidth; ax++)
|
|
alpha[ay, ax, 0] = 1f;
|
|
terrainData.SetAlphamaps(0, 0, alpha);
|
|
importedTextures++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Ortho texture missing for {tileId}: {orthoPath}");
|
|
}
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Imported {tileId} @ XZ=({ux},{uz}) Y={gmin} heightRange={heightRange} usedU16={usedU16}");
|
|
imported++;
|
|
placements.Add((tileId, ux, uz, (float)gmin));
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] DONE. Imported={imported}, Skipped={skipped}, OrthoApplied={importedTextures} under '{parentName}'.");
|
|
|
|
if (imported == 0)
|
|
Debug.LogError("[GeoTileImporter] Imported 0 tiles. Scroll up for warnings/errors (missing columns, parse issues, missing PNGs).");
|
|
|
|
ImportBuildings(placements);
|
|
ImportTrees(placements);
|
|
ImportFurniture(placements);
|
|
ImportEnhancedTrees(placements);
|
|
}
|
|
|
|
private void ImportBuildings(List<(string tileId, float ux, float uz, float gmin)> placements)
|
|
{
|
|
if (!importBuildings)
|
|
return;
|
|
|
|
// Choose directory based on enhanced toggle
|
|
string activeDir = useEnhancedBuildings ? buildingsEnhancedDir : buildingsDir;
|
|
string sourceLabel = useEnhancedBuildings ? "enhanced" : "standard";
|
|
|
|
if (!Directory.Exists(activeDir))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Buildings dir ({sourceLabel}) not found: {activeDir} (skipping buildings).");
|
|
return;
|
|
}
|
|
|
|
var parent = GameObject.Find(buildingsParentName);
|
|
if (parent == null) parent = new GameObject(buildingsParentName);
|
|
if (deleteExistingBuildings)
|
|
{
|
|
for (int i = parent.transform.childCount - 1; i >= 0; i--)
|
|
DestroyImmediate(parent.transform.GetChild(i).gameObject);
|
|
}
|
|
|
|
int imported = 0, missing = 0;
|
|
foreach (var (tileId, ux, uz, gmin) in placements)
|
|
{
|
|
string glbPath = Path.Combine(activeDir, $"{tileId}.glb").Replace("\\", "/");
|
|
if (!File.Exists(glbPath))
|
|
{
|
|
missing++;
|
|
Debug.LogWarning($"[GeoTileImporter] Building GLB ({sourceLabel}) missing for {tileId}: {glbPath}");
|
|
continue;
|
|
}
|
|
|
|
var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(glbPath);
|
|
if (prefab == null)
|
|
{
|
|
missing++;
|
|
Debug.LogWarning($"[GeoTileImporter] Could not load building GLB for {tileId}: {glbPath}");
|
|
continue;
|
|
}
|
|
|
|
var inst = PrefabUtility.InstantiatePrefab(prefab) as GameObject ?? Instantiate(prefab);
|
|
inst.name = tileId;
|
|
inst.transform.SetParent(parent.transform, false);
|
|
inst.transform.position = new Vector3(ux, gmin, uz);
|
|
inst.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
|
|
inst.isStatic = true;
|
|
imported++;
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Buildings ({sourceLabel}) imported={imported}, missing/failed={missing} under '{buildingsParentName}'.");
|
|
}
|
|
|
|
private void ImportTrees(List<(string tileId, float ux, float uz, float gmin)> placements)
|
|
{
|
|
if (!importTrees)
|
|
return;
|
|
|
|
if (!Directory.Exists(treesDir))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Trees dir not found: {treesDir} (skipping trees).");
|
|
return;
|
|
}
|
|
|
|
var parent = GameObject.Find(treesParentName);
|
|
if (parent == null) parent = new GameObject(treesParentName);
|
|
if (deleteExistingTrees)
|
|
{
|
|
for (int i = parent.transform.childCount - 1; i >= 0; i--)
|
|
DestroyImmediate(parent.transform.GetChild(i).gameObject);
|
|
}
|
|
|
|
if (!File.Exists(treeProxyPath))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Tree proxy GLB not found (for reference/materials): {treeProxyPath}");
|
|
}
|
|
|
|
int importedTiles = 0, importedChunks = 0, missingTiles = 0;
|
|
foreach (var (tileId, ux, uz, gmin) in placements)
|
|
{
|
|
// Look for chunk files: {tileId}_0_0.glb, {tileId}_0_1.glb, etc.
|
|
// Standard tree export creates 4x4 chunks per tile
|
|
var chunkFiles = Directory.GetFiles(treesDir, $"{tileId}_*.glb");
|
|
|
|
if (chunkFiles.Length == 0)
|
|
{
|
|
// Try single file as fallback
|
|
string singlePath = Path.Combine(treesDir, $"{tileId}.glb").Replace("\\", "/");
|
|
if (File.Exists(singlePath))
|
|
{
|
|
chunkFiles = new[] { singlePath };
|
|
}
|
|
else
|
|
{
|
|
missingTiles++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Create container for this tile's tree chunks
|
|
var tileContainer = new GameObject($"Trees_{tileId}");
|
|
tileContainer.transform.SetParent(parent.transform, false);
|
|
tileContainer.transform.position = new Vector3(ux, gmin, uz);
|
|
tileContainer.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
|
|
tileContainer.isStatic = true;
|
|
|
|
foreach (var chunkPath in chunkFiles)
|
|
{
|
|
string assetPath = chunkPath.Replace("\\", "/");
|
|
var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
|
|
if (prefab == null)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Could not load tree chunk: {assetPath}");
|
|
continue;
|
|
}
|
|
|
|
var inst = PrefabUtility.InstantiatePrefab(prefab) as GameObject ?? Instantiate(prefab);
|
|
inst.name = Path.GetFileNameWithoutExtension(chunkPath);
|
|
inst.transform.SetParent(tileContainer.transform, false);
|
|
inst.transform.localPosition = Vector3.zero; // Chunks already have correct local positions
|
|
inst.isStatic = true;
|
|
importedChunks++;
|
|
}
|
|
|
|
importedTiles++;
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Trees imported: {importedTiles} tiles, {importedChunks} chunks, {missingTiles} missing under '{treesParentName}'.");
|
|
}
|
|
|
|
private void ImportFurniture(List<(string tileId, float ux, float uz, float gmin)> placements)
|
|
{
|
|
if (!importFurniture)
|
|
return;
|
|
|
|
if (!Directory.Exists(furnitureDir))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Furniture dir not found: {furnitureDir} (skipping furniture).");
|
|
return;
|
|
}
|
|
|
|
var parent = GameObject.Find(furnitureParentName);
|
|
if (parent == null) parent = new GameObject(furnitureParentName);
|
|
if (deleteExistingFurniture)
|
|
{
|
|
for (int i = parent.transform.childCount - 1; i >= 0; i--)
|
|
DestroyImmediate(parent.transform.GetChild(i).gameObject);
|
|
}
|
|
|
|
int imported = 0, skipped = 0;
|
|
var ci = CultureInfo.InvariantCulture;
|
|
|
|
foreach (var (tileId, ux, uz, gmin) in placements)
|
|
{
|
|
string csvPath = Path.Combine(furnitureDir, $"{tileId}.csv").Replace("\\", "/");
|
|
if (!File.Exists(csvPath))
|
|
{
|
|
continue; // No furniture for this tile
|
|
}
|
|
|
|
var lines = File.ReadAllLines(csvPath);
|
|
if (lines.Length < 2)
|
|
continue;
|
|
|
|
// Parse header
|
|
var header = lines[0].Split(',');
|
|
int idxXLocal = -1, idxYLocal = -1, idxZGround = -1, idxHeight = -1, idxType = -1;
|
|
for (int i = 0; i < header.Length; i++)
|
|
{
|
|
var col = header[i].Trim().ToLowerInvariant();
|
|
if (col == "x_local") idxXLocal = i;
|
|
else if (col == "y_local") idxYLocal = i;
|
|
else if (col == "z_ground") idxZGround = i;
|
|
else if (col == "height") idxHeight = i;
|
|
else if (col == "type") idxType = i;
|
|
}
|
|
|
|
if (idxXLocal < 0 || idxYLocal < 0 || idxType < 0)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Furniture CSV missing required columns: {csvPath}");
|
|
continue;
|
|
}
|
|
|
|
// Create tile container
|
|
var tileContainer = new GameObject($"Furniture_{tileId}");
|
|
tileContainer.transform.SetParent(parent.transform, false);
|
|
tileContainer.transform.position = new Vector3(ux, gmin, uz);
|
|
tileContainer.isStatic = true;
|
|
|
|
for (int i = 1; i < lines.Length; i++)
|
|
{
|
|
var parts = lines[i].Split(',');
|
|
if (parts.Length <= Math.Max(Math.Max(idxXLocal, idxYLocal), idxType))
|
|
{
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
float xLocal = float.Parse(parts[idxXLocal].Trim(), ci);
|
|
float yLocal = float.Parse(parts[idxYLocal].Trim(), ci);
|
|
float zGround = idxZGround >= 0 && idxZGround < parts.Length
|
|
? float.Parse(parts[idxZGround].Trim(), ci)
|
|
: 0f;
|
|
float height = idxHeight >= 0 && idxHeight < parts.Length
|
|
? float.Parse(parts[idxHeight].Trim(), ci)
|
|
: 1f;
|
|
string furnitureType = parts[idxType].Trim().ToLowerInvariant();
|
|
|
|
// Select prefab based on type, or create placeholder
|
|
GameObject obj = null;
|
|
GameObject prefabToUse = null;
|
|
Vector3 fallbackScale = Vector3.one;
|
|
|
|
switch (furnitureType)
|
|
{
|
|
case "lamp":
|
|
prefabToUse = lampPrefab;
|
|
fallbackScale = new Vector3(0.3f, height, 0.3f);
|
|
break;
|
|
case "bench":
|
|
prefabToUse = benchPrefab;
|
|
fallbackScale = new Vector3(1.5f, height, 0.5f);
|
|
break;
|
|
case "sign":
|
|
prefabToUse = signPrefab;
|
|
fallbackScale = new Vector3(0.1f, height, 0.5f);
|
|
break;
|
|
case "bollard":
|
|
prefabToUse = bollardPrefab;
|
|
fallbackScale = new Vector3(0.2f, height, 0.2f);
|
|
break;
|
|
default:
|
|
prefabToUse = defaultFurniturePrefab;
|
|
fallbackScale = new Vector3(0.5f, height, 0.5f);
|
|
break;
|
|
}
|
|
|
|
if (prefabToUse != null)
|
|
{
|
|
// Use prefab
|
|
obj = PrefabUtility.InstantiatePrefab(prefabToUse) as GameObject ?? Instantiate(prefabToUse);
|
|
obj.name = $"{furnitureType}_{i}";
|
|
// Scale prefab to match height (assuming prefab is normalized to ~1m)
|
|
float scaleMultiplier = height;
|
|
obj.transform.localScale = Vector3.one * scaleMultiplier;
|
|
}
|
|
else
|
|
{
|
|
// Create placeholder cube
|
|
obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
|
obj.name = $"{furnitureType}_{i}";
|
|
obj.transform.localScale = fallbackScale;
|
|
}
|
|
|
|
obj.transform.SetParent(tileContainer.transform, false);
|
|
obj.transform.localPosition = new Vector3(xLocal, zGround - gmin, yLocal);
|
|
obj.isStatic = true;
|
|
imported++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Failed to parse furniture line {i} in {csvPath}: {e.Message}");
|
|
skipped++;
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Furniture imported={imported}, skipped={skipped} under '{furnitureParentName}'.");
|
|
}
|
|
|
|
private void ImportEnhancedTrees(List<(string tileId, float ux, float uz, float gmin)> placements)
|
|
{
|
|
if (!importEnhancedTrees)
|
|
return;
|
|
|
|
if (!Directory.Exists(enhancedTreesDir))
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Enhanced trees dir not found: {enhancedTreesDir} (skipping enhanced trees).");
|
|
return;
|
|
}
|
|
|
|
var parent = GameObject.Find(enhancedTreesParentName);
|
|
if (parent == null) parent = new GameObject(enhancedTreesParentName);
|
|
if (deleteExistingEnhancedTrees)
|
|
{
|
|
for (int i = parent.transform.childCount - 1; i >= 0; i--)
|
|
DestroyImmediate(parent.transform.GetChild(i).gameObject);
|
|
}
|
|
|
|
int imported = 0, skipped = 0;
|
|
var ci = CultureInfo.InvariantCulture;
|
|
|
|
foreach (var (tileId, ux, uz, gmin) in placements)
|
|
{
|
|
string csvPath = Path.Combine(enhancedTreesDir, $"{tileId}.csv").Replace("\\", "/");
|
|
if (!File.Exists(csvPath))
|
|
{
|
|
continue; // No enhanced trees for this tile
|
|
}
|
|
|
|
var lines = File.ReadAllLines(csvPath);
|
|
if (lines.Length < 2)
|
|
continue;
|
|
|
|
// Parse header
|
|
var header = lines[0].Split(',');
|
|
int idxXLocal = -1, idxYLocal = -1, idxZGround = -1, idxHeight = -1, idxRadius = -1;
|
|
int idxCanopyR = -1, idxCanopyG = -1, idxCanopyB = -1;
|
|
for (int i = 0; i < header.Length; i++)
|
|
{
|
|
var col = header[i].Trim().ToLowerInvariant();
|
|
if (col == "x_local") idxXLocal = i;
|
|
else if (col == "y_local") idxYLocal = i;
|
|
else if (col == "z_ground") idxZGround = i;
|
|
else if (col == "height") idxHeight = i;
|
|
else if (col == "radius") idxRadius = i;
|
|
else if (col == "canopy_r") idxCanopyR = i;
|
|
else if (col == "canopy_g") idxCanopyG = i;
|
|
else if (col == "canopy_b") idxCanopyB = i;
|
|
}
|
|
|
|
if (idxXLocal < 0 || idxYLocal < 0 || idxHeight < 0)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Enhanced trees CSV missing required columns: {csvPath}");
|
|
continue;
|
|
}
|
|
|
|
// Create tile container
|
|
var tileContainer = new GameObject($"Trees_{tileId}");
|
|
tileContainer.transform.SetParent(parent.transform, false);
|
|
tileContainer.transform.position = new Vector3(ux, gmin, uz);
|
|
tileContainer.isStatic = true;
|
|
|
|
for (int i = 1; i < lines.Length; i++)
|
|
{
|
|
var parts = lines[i].Split(',');
|
|
if (parts.Length <= Math.Max(Math.Max(idxXLocal, idxYLocal), idxHeight))
|
|
{
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
float xLocal = float.Parse(parts[idxXLocal].Trim(), ci);
|
|
float yLocal = float.Parse(parts[idxYLocal].Trim(), ci);
|
|
float zGround = idxZGround >= 0 && idxZGround < parts.Length
|
|
? float.Parse(parts[idxZGround].Trim(), ci)
|
|
: 0f;
|
|
float height = float.Parse(parts[idxHeight].Trim(), ci);
|
|
float radius = idxRadius >= 0 && idxRadius < parts.Length
|
|
? float.Parse(parts[idxRadius].Trim(), ci)
|
|
: height * 0.25f;
|
|
|
|
// Parse canopy color (default to green if missing)
|
|
int canopyR = 128, canopyG = 160, canopyB = 80;
|
|
if (idxCanopyR >= 0 && idxCanopyR < parts.Length)
|
|
canopyR = Mathf.Clamp(int.Parse(parts[idxCanopyR].Trim()), 0, 255);
|
|
if (idxCanopyG >= 0 && idxCanopyG < parts.Length)
|
|
canopyG = Mathf.Clamp(int.Parse(parts[idxCanopyG].Trim()), 0, 255);
|
|
if (idxCanopyB >= 0 && idxCanopyB < parts.Length)
|
|
canopyB = Mathf.Clamp(int.Parse(parts[idxCanopyB].Trim()), 0, 255);
|
|
|
|
Color canopyColor = new Color(canopyR / 255f, canopyG / 255f, canopyB / 255f);
|
|
|
|
GameObject treeObj;
|
|
if (treePrefab != null)
|
|
{
|
|
// Use prefab instance
|
|
treeObj = PrefabUtility.InstantiatePrefab(treePrefab) as GameObject ?? Instantiate(treePrefab);
|
|
treeObj.name = $"tree_{i}";
|
|
|
|
// Scale prefab based on height/radius
|
|
float scaleY = height / 10f; // Assuming prefab is ~10m tall
|
|
float scaleXZ = radius * 2f / 5f; // Assuming prefab canopy is ~5m wide
|
|
treeObj.transform.localScale = new Vector3(scaleXZ, scaleY, scaleXZ);
|
|
|
|
// Apply canopy color to materials
|
|
var renderers = treeObj.GetComponentsInChildren<Renderer>();
|
|
foreach (var rend in renderers)
|
|
{
|
|
foreach (var mat in rend.sharedMaterials)
|
|
{
|
|
if (mat != null)
|
|
{
|
|
// Create material instance to avoid modifying shared material
|
|
var matInst = new Material(mat);
|
|
matInst.color = canopyColor;
|
|
rend.material = matInst;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Create procedural tree placeholder (cylinder trunk + sphere canopy)
|
|
treeObj = new GameObject($"tree_{i}");
|
|
|
|
// Trunk (cylinder)
|
|
var trunk = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
|
|
trunk.name = "trunk";
|
|
trunk.transform.SetParent(treeObj.transform, false);
|
|
trunk.transform.localPosition = new Vector3(0, height * 0.25f, 0);
|
|
trunk.transform.localScale = new Vector3(0.3f, height * 0.5f, 0.3f);
|
|
var trunkRend = trunk.GetComponent<Renderer>();
|
|
if (trunkRend != null)
|
|
{
|
|
var trunkMat = new Material(Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard"));
|
|
trunkMat.color = new Color(0.4f, 0.25f, 0.15f); // Brown
|
|
trunkRend.material = trunkMat;
|
|
}
|
|
|
|
// Canopy (sphere)
|
|
var canopy = GameObject.CreatePrimitive(PrimitiveType.Sphere);
|
|
canopy.name = "canopy";
|
|
canopy.transform.SetParent(treeObj.transform, false);
|
|
canopy.transform.localPosition = new Vector3(0, height * 0.7f, 0);
|
|
canopy.transform.localScale = new Vector3(radius * 2f, height * 0.5f, radius * 2f);
|
|
var canopyRend = canopy.GetComponent<Renderer>();
|
|
if (canopyRend != null)
|
|
{
|
|
var canopyMat = new Material(Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard"));
|
|
canopyMat.color = canopyColor;
|
|
canopyRend.material = canopyMat;
|
|
}
|
|
}
|
|
|
|
treeObj.transform.SetParent(tileContainer.transform, false);
|
|
treeObj.transform.localPosition = new Vector3(xLocal, zGround - gmin, yLocal);
|
|
treeObj.isStatic = true;
|
|
imported++;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogWarning($"[GeoTileImporter] Failed to parse enhanced tree line {i} in {csvPath}: {e.Message}");
|
|
skipped++;
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Log($"[GeoTileImporter] Enhanced trees imported={imported}, skipped={skipped} under '{enhancedTreesParentName}'.");
|
|
}
|
|
}
|