Terrain.cs

namespace RustMapViewer;

public sealed class HeightMap
{
	public const float TerrainHeight = 1000f;
	public const float TerrainOffsetY = -500f;

	private readonly short[] _data;
	public readonly int Res;
	public readonly float WorldSize;
	private readonly float _half;

	public HeightMap(byte[] raw, float worldSize)
	{
		Res = (int)Math.Sqrt(raw.Length / 2.0);
		if (Res * Res * 2 != raw.Length)
		{
			throw new InvalidDataException($"Unexpected terrain map length {raw.Length}");
		}

		_data = new short[Res * Res];
		Buffer.BlockCopy(raw, 0, _data, 0, raw.Length);
		WorldSize = worldSize;
		_half = worldSize * 0.5f;
	}

	public float GetHeightIdx(int x, int z) => _data[z * Res + x] * (1f / 32766f) * TerrainHeight + TerrainOffsetY;

	public float GetHeight(float worldX, float worldZ)
	{
		float gx = Math.Clamp((worldX + _half) / WorldSize, 0f, 1f) * (Res - 1);
		float gz = Math.Clamp((worldZ + _half) / WorldSize, 0f, 1f) * (Res - 1);

		int x0 = (int)gx;
		int z0 = (int)gz;
		int x1 = Math.Min(x0 + 1, Res - 1);
		int z1 = Math.Min(z0 + 1, Res - 1);
		float fx = gx - x0;
		float fz = gz - z0;

		float h00 = GetHeightIdx(x0, z0);
		float h10 = GetHeightIdx(x1, z0);
		float h01 = GetHeightIdx(x0, z1);
		float h11 = GetHeightIdx(x1, z1);

		return float.Lerp(float.Lerp(h00, h10, fx), float.Lerp(h01, h11, fx), fz);
	}

	public float TexelSize => WorldSize / (Res - 1);

	public (float worldX, float worldZ) IdxToWorld(int x, int z) => (x * TexelSize - _half, z * TexelSize - _half);

	public byte[] RawBytes()
	{
		byte[] bytes = new byte[_data.Length * 2];
		Buffer.BlockCopy(_data, 0, bytes, 0, bytes.Length);
		return bytes;
	}

	public HeightMap Clone() => new(RawBytes(), WorldSize);

	public void RaiseIdx(int x, int z, float worldY)
	{
		short encoded = (short)Math.Clamp((worldY - TerrainOffsetY) / TerrainHeight * 32766f, short.MinValue, short.MaxValue);
		int index = z * Res + x;
		if (encoded > _data[index])
		{
			_data[index] = encoded;
		}
	}

	public int WorldToIdxX(float worldX) => Math.Clamp((int)((worldX + _half) / WorldSize * (Res - 1) + 0.5f), 0, Res - 1);
	public int WorldToIdxZ(float worldZ) => Math.Clamp((int)((worldZ + _half) / WorldSize * (Res - 1) + 0.5f), 0, Res - 1);
}

public sealed class TopologyMap
{
	private readonly int[] _data;
	public readonly int Res;
	private readonly float _worldSize;
	private readonly float _half;

	public TopologyMap(byte[] raw, float worldSize)
	{
		Res = (int)Math.Sqrt(raw.Length / 4.0);
		if (Res * Res * 4 != raw.Length)
		{
			throw new InvalidDataException($"Unexpected topology map length {raw.Length}");
		}

		_data = new int[Res * Res];
		Buffer.BlockCopy(raw, 0, _data, 0, raw.Length);
		_worldSize = worldSize;
		_half = worldSize * 0.5f;
	}

	public int GetTopologyIdx(int x, int z) => _data[z * Res + x];

	public int GetTopology(float worldX, float worldZ)
	{
		int x = Math.Clamp((int)((worldX + _half) / _worldSize * Res), 0, Res - 1);
		int z = Math.Clamp((int)((worldZ + _half) / _worldSize * Res), 0, Res - 1);
		return _data[z * Res + x];
	}
}

public sealed class SplatMap
{
	public const int Channels = 8;

	private readonly byte[] _data;
	public readonly int Res;
	private readonly float _worldSize;
	private readonly float _half;

	public SplatMap(byte[] raw, float worldSize)
	{
		Res = (int)Math.Sqrt(raw.Length / (double)Channels);
		if (Res * Res * Channels != raw.Length)
		{
			throw new InvalidDataException($"Unexpected splat map length {raw.Length}");
		}

		_data = raw;
		_worldSize = worldSize;
		_half = worldSize * 0.5f;
	}

	public float GetSplat(float worldX, float worldZ, int channel)
	{
		float gx = Math.Clamp((worldX + _half) / _worldSize, 0f, 1f) * (Res - 1);
		float gz = Math.Clamp((worldZ + _half) / _worldSize, 0f, 1f) * (Res - 1);

		int x0 = (int)gx;
		int z0 = (int)gz;
		int x1 = Math.Min(x0 + 1, Res - 1);
		int z1 = Math.Min(z0 + 1, Res - 1);
		float fx = gx - x0;
		float fz = gz - z0;

		int plane = channel * Res;
		float v00 = _data[(plane + z0) * Res + x0];
		float v10 = _data[(plane + z0) * Res + x1];
		float v01 = _data[(plane + z1) * Res + x0];
		float v11 = _data[(plane + z1) * Res + x1];

		return float.Lerp(float.Lerp(v00, v10, fx), float.Lerp(v01, v11, fx), fz) * (1f / 255f);
	}

	public byte Raw(int channel, int x, int z) => _data[(channel * Res + z) * Res + x];
}

public static class Topo
{
	public const int Field = 1;
	public const int Cliff = 2;
	public const int Summit = 4;
	public const int Ocean = 0x80;
	public const int Monument = 0x400;
	public const int Road = 0x800;
	public const int Roadside = 0x1000;
	public const int Swamp = 0x2000;
	public const int River = 0x4000;
	public const int Riverside = 0x8000;
	public const int Lake = 0x10000;
	public const int Lakeside = 0x20000;
	public const int Offshore = 0x40000;
	public const int Rail = 0x80000;
	public const int Railside = 0x100000;
	public const int Building = 0x200000;
	public const int Cliffside = 0x400000;
	public const int Mountain = 0x800000;

	public const int Water = Ocean | River | Lake | Offshore;
	public const int WaterSide = Riverside | Lakeside | Swamp;
}