feat: raw terrain parsing for scene data

Replace old dNavigation/dTerrain raw parser with new Raw module in
dZoneManager. Parse heightmaps, color maps, and scene maps from .raw
files to determine which scene a position belongs to. Build scene
adjacency graph from terrain data and scene transitions.

Adds NiColor type, SceneColor lookup table, eSceneType enum, terrain
mesh generation with OBJ export, and debug slash commands for scene
visualization.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

dZoneManager/CMakeLists.txt

@@ -1,5 +1,6 @@
 set(DZONEMANAGER_SOURCES "dZoneManager.cpp"
 	"Level.cpp"
+	"Raw.cpp"
 	"Spawner.cpp"
 	"Zone.cpp")
 
@@ -14,6 +15,7 @@ target_include_directories(dZoneManager PUBLIC "."
 	"${PROJECT_SOURCE_DIR}/dGame" # Entity.h
 	"${PROJECT_SOURCE_DIR}/dGame/dEntity" # EntityInfo.h
 	PRIVATE
+	"${PROJECT_SOURCE_DIR}/dCommon/dClient" # SceneColors.h
 	"${PROJECT_SOURCE_DIR}/dGame/dComponents" #InventoryComponent.h
 	"${PROJECT_SOURCE_DIR}/dGame/dInventory" #InventoryComponent.h (transitive)
 	"${PROJECT_SOURCE_DIR}/dGame/dBehaviors" #BehaviorSlot.h

dZoneManager/Raw.cpp

@@ -0,0 +1,481 @@
+#include "Raw.h"
+#include "BinaryIO.h"
+#include "Logger.h"
+#include "SceneColor.h"
+#include <fstream>
+#include <algorithm>
+#include <limits>
+
+namespace {
+constexpr uint32_t kMaxResolution = 4096;
+constexpr size_t kMaxBlobBytes = 64ULL * 1024 * 1024; // 64 MiB
+constexpr uint32_t kMaxChunks = 1024;
+} // namespace
+
+namespace Raw {
+
+	/**
+	 * @brief Read flair attributes from stream
+	 */
+	static bool ReadFlairAttributes(std::istream& stream, FlairAttributes& flair) {
+		try {
+			BinaryIO::BinaryRead(stream, flair.id);
+			BinaryIO::BinaryRead(stream, flair.scaleFactor);
+			BinaryIO::BinaryRead(stream, flair.position.x);
+			BinaryIO::BinaryRead(stream, flair.position.y);
+			BinaryIO::BinaryRead(stream, flair.position.z);
+			BinaryIO::BinaryRead(stream, flair.rotation.x);
+			BinaryIO::BinaryRead(stream, flair.rotation.y);
+			BinaryIO::BinaryRead(stream, flair.rotation.z);
+			BinaryIO::BinaryRead(stream, flair.colorR);
+			BinaryIO::BinaryRead(stream, flair.colorG);
+			BinaryIO::BinaryRead(stream, flair.colorB);
+			BinaryIO::BinaryRead(stream, flair.colorA);
+			return true;
+		} catch (const std::exception&) {
+			return false;
+		}
+	}
+
+	/**
+	 * @brief Read mesh triangle data from stream
+	 */
+	static bool ReadMeshTri(std::istream& stream, MeshTri& meshTri) {
+		try {
+			BinaryIO::BinaryRead(stream, meshTri.meshTriListSize);
+			meshTri.meshTriList.resize(meshTri.meshTriListSize);
+			for (uint16_t i = 0; i < meshTri.meshTriListSize; ++i) {
+				BinaryIO::BinaryRead(stream, meshTri.meshTriList[i]);
+			}
+			return true;
+		} catch (const std::exception&) {
+			return false;
+		}
+	}
+
+	/**
+	 * @brief Read a chunk from stream
+	 */
+	static bool ReadChunk(std::istream& stream, Chunk& chunk, uint16_t version) {
+		try {
+			// Read basic chunk info
+			BinaryIO::BinaryRead(stream, chunk.id);
+			if (stream.fail()) {
+				return false;
+			}
+
+			BinaryIO::BinaryRead(stream, chunk.width);
+			BinaryIO::BinaryRead(stream, chunk.height);
+			BinaryIO::BinaryRead(stream, chunk.offsetX);
+			BinaryIO::BinaryRead(stream, chunk.offsetZ);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// For version < 32, shader ID comes before texture IDs
+			if (version < 32) {
+				BinaryIO::BinaryRead(stream, chunk.shaderId);
+			}
+
+			// Read texture IDs (4 textures)
+			chunk.textureIds.resize(4);
+			for (int i = 0; i < 4; ++i) {
+				BinaryIO::BinaryRead(stream, chunk.textureIds[i]);
+			}
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Read scale factor
+			BinaryIO::BinaryRead(stream, chunk.scaleFactor);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Read heightmap
+			const size_t width = static_cast<size_t>(chunk.width);
+			const size_t height = static_cast<size_t>(chunk.height);
+
+			if (width == 0 || height == 0) {
+				LOG("Chunk %u has invalid heightmap dimensions: width=%zu, height=%zu", chunk.id, width, height);
+				return false;
+			}
+
+			if (width > kMaxResolution || height > kMaxResolution) {
+				LOG("Chunk %u heightmap dimensions exceed maximum resolution %u: width=%zu, height=%zu", chunk.id, kMaxResolution, width, height);
+				return false;
+			}
+
+			if (height != 0 && width > std::numeric_limits<size_t>::max() / height) {
+				LOG("Chunk %u heightmap size multiplication overflows: width=%zu, height=%zu", chunk.id, width, height);
+				return false;
+			}
+
+			const size_t heightMapSize = width * height;
+			const size_t elementSize = sizeof(chunk.heightMap[0]);
+
+			if (elementSize != 0 && heightMapSize > std::numeric_limits<size_t>::max() / elementSize) {
+				LOG("Chunk %u heightmap byte size overflows: elements=%zu, elementSize=%zu", chunk.id, heightMapSize, elementSize);
+				return false;
+			}
+
+			const size_t totalBytes = heightMapSize * elementSize;
+			if (totalBytes == 0 || totalBytes > kMaxBlobBytes) {
+				LOG("Chunk %u heightmap total size invalid: bytes=%zu (max %zu)", chunk.id, totalBytes, kMaxBlobBytes);
+				return false;
+			}
+
+			chunk.heightMap.resize(heightMapSize);
+			for (size_t i = 0; i < heightMapSize; ++i) {
+				BinaryIO::BinaryRead(stream, chunk.heightMap[i]);
+			}
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// ColorMap
+			if (version >= 32) {
+				BinaryIO::BinaryRead(stream, chunk.colorMapResolution);
+			} else {
+				chunk.colorMapResolution = chunk.width; // Default to chunk width for older versions
+			}
+
+			if (chunk.colorMapResolution > kMaxResolution) {
+				LOG("Chunk colorMapResolution %u exceeds maximum %u", chunk.colorMapResolution, kMaxResolution);
+				return false;
+			}
+			const size_t colorMapPixelCount = static_cast<size_t>(chunk.colorMapResolution) * chunk.colorMapResolution * 4; // RGBA
+			if (colorMapPixelCount > kMaxBlobBytes) {
+				LOG("Chunk colorMap size %zu exceeds maximum %zu bytes", colorMapPixelCount, kMaxBlobBytes);
+				return false;
+			}
+			chunk.colorMap.resize(colorMapPixelCount);
+			stream.read(reinterpret_cast<char*>(chunk.colorMap.data()), static_cast<std::streamsize>(colorMapPixelCount));
+
+			if (stream.fail()) {
+				return false;
+			}
+			// LightMap/diffusemap.dds
+			uint32_t lightMapSize;
+			BinaryIO::BinaryRead(stream, lightMapSize);
+
+			if (lightMapSize > kMaxBlobBytes) {
+				LOG("Chunk lightMap size %u exceeds maximum %zu bytes", lightMapSize, kMaxBlobBytes);
+				return false;
+			}
+			chunk.lightMap.resize(lightMapSize);
+			stream.read(reinterpret_cast<char*>(chunk.lightMap.data()), static_cast<std::streamsize>(lightMapSize));
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// TextureMap
+			if (version >= 32) {
+				BinaryIO::BinaryRead(stream, chunk.textureMapResolution);
+			} else {
+				chunk.textureMapResolution = chunk.width; // Default to chunk width for older versions
+			}
+
+			if (chunk.textureMapResolution > kMaxResolution) {
+				LOG("Chunk textureMapResolution %u exceeds maximum %u", chunk.textureMapResolution, kMaxResolution);
+				return false;
+			}
+			const size_t textureMapPixelCount = static_cast<size_t>(chunk.textureMapResolution) * chunk.textureMapResolution * 4;
+			if (textureMapPixelCount > kMaxBlobBytes) {
+				LOG("Chunk textureMap size %zu exceeds maximum %zu bytes", textureMapPixelCount, kMaxBlobBytes);
+				return false;
+			}
+			chunk.textureMap.resize(textureMapPixelCount);
+			stream.read(reinterpret_cast<char*>(chunk.textureMap.data()), static_cast<std::streamsize>(textureMapPixelCount));
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Texture settings
+			BinaryIO::BinaryRead(stream, chunk.textureSettings);
+
+			// Blend map DDS
+			uint32_t blendMapDDSSize;
+			BinaryIO::BinaryRead(stream, blendMapDDSSize);
+
+			if (blendMapDDSSize > kMaxBlobBytes) {
+				LOG("Chunk blendMap size %u exceeds maximum %zu bytes", blendMapDDSSize, kMaxBlobBytes);
+				return false;
+			}
+			chunk.blendMap.resize(blendMapDDSSize);
+			stream.read(reinterpret_cast<char*>(chunk.blendMap.data()), static_cast<std::streamsize>(blendMapDDSSize));
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Read flairs
+			uint32_t numFlairs;
+			BinaryIO::BinaryRead(stream, numFlairs);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			const size_t flairBytes = static_cast<size_t>(numFlairs) * sizeof(FlairAttributes);
+			if (flairBytes > kMaxBlobBytes) {
+				LOG("Chunk %u flair count %u exceeds maximum (byte size %zu > %zu)", chunk.id, numFlairs, flairBytes, kMaxBlobBytes);
+				return false;
+			}
+			chunk.flairs.resize(numFlairs);
+			for (uint32_t i = 0; i < numFlairs; ++i) {
+				if (!ReadFlairAttributes(stream, chunk.flairs[i])) {
+					return false;
+				}
+			}
+
+			// Scene map (version 32+ only)
+			if (version >= 32) {
+				const size_t sceneMapSize = static_cast<size_t>(chunk.colorMapResolution) * chunk.colorMapResolution;
+
+				if (sceneMapSize > kMaxBlobBytes) {
+					LOG("Chunk sceneMap size %zu exceeds maximum %zu bytes", sceneMapSize, kMaxBlobBytes);
+					return false;
+				}
+				chunk.sceneMap.resize(sceneMapSize);
+				stream.read(reinterpret_cast<char*>(chunk.sceneMap.data()), static_cast<std::streamsize>(sceneMapSize));
+
+				if (stream.fail()) {
+					return false;
+				}
+			}
+
+			// Mesh vertex usage (read size first, then check if empty)
+			BinaryIO::BinaryRead(stream, chunk.vertSize);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Mesh vert usage
+			const size_t vertBytes = static_cast<size_t>(chunk.vertSize) * sizeof(uint16_t);
+			if (vertBytes > kMaxBlobBytes) {
+				LOG("Chunk %u vertSize %u exceeds maximum (byte size %zu > %zu)", chunk.id, chunk.vertSize, vertBytes, kMaxBlobBytes);
+				return false;
+			}
+			chunk.meshVertUsage.resize(chunk.vertSize);
+			for (uint32_t i = 0; i < chunk.vertSize; ++i) {
+				BinaryIO::BinaryRead(stream, chunk.meshVertUsage[i]);
+			}
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Only continue with mesh data if we have vertex usage data
+			if (chunk.vertSize == 0) {
+				return true;
+			}
+
+			// Mesh vert size (16 elements)
+			chunk.meshVertSize.resize(16);
+			for (int i = 0; i < 16; ++i) {
+				BinaryIO::BinaryRead(stream, chunk.meshVertSize[i]);
+			}
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Mesh triangles (16 elements)
+			chunk.meshTri.resize(16);
+			for (int i = 0; i < 16; ++i) {
+				if (!ReadMeshTri(stream, chunk.meshTri[i])) {
+					return false;
+				}
+			}
+
+			return true;
+		} catch (const std::exception&) {
+			return false;
+		}
+	}
+
+	bool ReadRaw(std::istream& stream, Raw& outRaw) {
+		// Get stream size
+		stream.seekg(0, std::ios::end);
+		auto streamSize = stream.tellg();
+		stream.seekg(0, std::ios::beg);
+
+		if (streamSize <= 0) {
+			return false;
+		}
+
+		try {
+			// Read header
+			BinaryIO::BinaryRead(stream, outRaw.version);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			BinaryIO::BinaryRead(stream, outRaw.dev);
+
+			if (stream.fail()) {
+				return false;
+			}
+
+			// Only read chunks if dev == 0
+			if (outRaw.dev == 0) {
+				BinaryIO::BinaryRead(stream, outRaw.numChunks);
+				BinaryIO::BinaryRead(stream, outRaw.numChunksWidth);
+				BinaryIO::BinaryRead(stream, outRaw.numChunksHeight);
+
+				if (outRaw.numChunks > kMaxChunks) {
+					LOG("Raw numChunks %u exceeds maximum %u", outRaw.numChunks, kMaxChunks);
+					return false;
+				}
+
+				// Read all chunks
+				outRaw.chunks.resize(outRaw.numChunks);
+				for (uint32_t i = 0; i < outRaw.numChunks; ++i) {
+					if (!ReadChunk(stream, outRaw.chunks[i], outRaw.version)) {
+						return false;
+					}
+				}
+				
+				// Calculate terrain bounds from all chunks
+				if (!outRaw.chunks.empty()) {
+					outRaw.minBoundsX = std::numeric_limits<float>::max();
+					outRaw.minBoundsZ = std::numeric_limits<float>::max();
+					outRaw.maxBoundsX = std::numeric_limits<float>::lowest();
+					outRaw.maxBoundsZ = std::numeric_limits<float>::lowest();
+
+					for (const auto& chunk : outRaw.chunks) {
+						const float chunkMinX = chunk.offsetX;
+						const float chunkMinZ = chunk.offsetZ;
+						const float chunkMaxX = chunkMinX + (chunk.width * chunk.scaleFactor);
+						const float chunkMaxZ = chunkMinZ + (chunk.height * chunk.scaleFactor);
+
+						outRaw.minBoundsX = std::min(outRaw.minBoundsX, chunkMinX);
+						outRaw.minBoundsZ = std::min(outRaw.minBoundsZ, chunkMinZ);
+						outRaw.maxBoundsX = std::max(outRaw.maxBoundsX, chunkMaxX);
+						outRaw.maxBoundsZ = std::max(outRaw.maxBoundsZ, chunkMaxZ);
+					}
+					LOG("Raw terrain bounds: X[%.2f, %.2f], Z[%.2f, %.2f]",
+						outRaw.minBoundsX, outRaw.maxBoundsX, outRaw.minBoundsZ, outRaw.maxBoundsZ);
+				}
+			}
+			return true;
+		} catch (const std::exception&) {
+			return false;
+		}
+	}
+
+	void GenerateTerrainMesh(const Raw& raw, TerrainMesh& outMesh) {
+		outMesh.vertices.clear();
+		outMesh.triangles.clear();
+
+		if (raw.chunks.empty() || raw.version < 32) {
+			return; // No scene data available
+		}
+
+		LOG("GenerateTerrainMesh: Processing %zu chunks", raw.chunks.size());
+
+		uint32_t vertexOffset = 0;
+
+		for (const auto& chunk : raw.chunks) {
+			// Skip chunks without scene maps or with invalid dimensions/scale
+			if (chunk.sceneMap.empty() || chunk.colorMapResolution == 0 || chunk.heightMap.empty()
+				|| chunk.scaleFactor <= 0.0f || chunk.width <= 1 || chunk.height <= 1) {
+				LOG("Skipping chunk %u (sceneMap: %zu, colorMapRes: %u, heightMap: %zu, scaleFactor: %f, width: %u, height: %u)", 
+					chunk.id, chunk.sceneMap.size(), chunk.colorMapResolution, chunk.heightMap.size(),
+					chunk.scaleFactor, chunk.width, chunk.height);
+				continue;
+			}
+
+			LOG("Processing chunk %u: width=%u, height=%u, colorMapRes=%u, sceneMapSize=%zu", 
+				chunk.id, chunk.width, chunk.height, chunk.colorMapResolution, chunk.sceneMap.size());
+
+			// Generate vertices for this chunk
+			for (uint32_t i = 0; i < chunk.width; ++i) {
+				for (uint32_t j = 0; j < chunk.height; ++j) {
+					// Get height at this position
+					const uint32_t heightIndex = chunk.width * i + j;
+					if (heightIndex >= chunk.heightMap.size()) continue;
+					
+					const float y = chunk.heightMap[heightIndex];
+
+					const float worldX = (static_cast<float>(i) + (chunk.offsetX / chunk.scaleFactor)) * chunk.scaleFactor;
+					const float worldY = y;
+					const float worldZ = (static_cast<float>(j) + (chunk.offsetZ / chunk.scaleFactor)) * chunk.scaleFactor;
+
+					const NiPoint3 worldPos(worldX, worldY, worldZ);
+
+					const float sceneMapI = (static_cast<float>(i) / static_cast<float>(chunk.width - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
+					const float sceneMapJ = (static_cast<float>(j) / static_cast<float>(chunk.height - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
+
+					const uint32_t sceneI = std::min(static_cast<uint32_t>(sceneMapI), chunk.colorMapResolution - 1);
+					const uint32_t sceneJ = std::min(static_cast<uint32_t>(sceneMapJ), chunk.colorMapResolution - 1);
+					const uint32_t sceneIndex = sceneI * chunk.colorMapResolution + sceneJ;
+
+					uint8_t sceneID = 0;
+					if (sceneIndex < chunk.sceneMap.size()) {
+						sceneID = chunk.sceneMap[sceneIndex];
+					}
+					outMesh.vertices.emplace_back(worldPos, sceneID);
+					if (i > 0 && j > 0) {
+						const uint32_t currentVert = vertexOffset + chunk.width * i + j;
+						const uint32_t leftVert = currentVert - 1;
+						const uint32_t bottomLeftVert = vertexOffset + chunk.width * (i - 1) + j - 1;
+						const uint32_t bottomVert = vertexOffset + chunk.width * (i - 1) + j;
+
+						// First triangle
+						outMesh.triangles.push_back(currentVert);
+						outMesh.triangles.push_back(leftVert);
+						outMesh.triangles.push_back(bottomLeftVert);
+
+						// Second triangle
+						outMesh.triangles.push_back(bottomLeftVert);
+						outMesh.triangles.push_back(bottomVert);
+						outMesh.triangles.push_back(currentVert);
+					}
+				}
+			}
+
+			vertexOffset += chunk.width * chunk.height;
+		}
+	}
+
+	bool WriteTerrainMeshToOBJ(const TerrainMesh& mesh, const std::string& path) {
+		try {
+			std::ofstream file(path);
+			if (!file.is_open()) {
+				LOG("Failed to open OBJ file for writing: %s", path.c_str());
+				return false;
+			}
+
+			for (const auto& v : mesh.vertices) {
+				const NiColor& color = SceneColor::Get(v.sceneID);
+				file << "v " << v.position.x << ' ' << v.position.y << ' ' << v.position.z
+					<< ' ' << color.m_Red << ' ' << color.m_Green << ' ' << color.m_Blue << '\n';
+			}
+
+			for (size_t i = 0; i < mesh.triangles.size(); i += 3) {
+				file << "f " << (mesh.triangles[i] + 1) << ' '
+					<< (mesh.triangles[i + 1] + 1) << ' '
+					<< (mesh.triangles[i + 2] + 1) << '\n';
+			}
+
+			file.close();
+			LOG("Successfully wrote terrain mesh to OBJ: %s (%zu vertices, %zu triangles)",
+				path.c_str(), mesh.vertices.size(), mesh.triangles.size() / 3);
+			return true;
+		} catch (const std::exception& e) {
+			LOG("Exception while writing OBJ file: %s", e.what());
+			return false;
+		}
+	}
+
+} // namespace Raw

dZoneManager/Raw.h

@@ -0,0 +1,158 @@
+#pragma once
+
+#ifndef __RAW_H__
+#define __RAW_H__
+
+#include <cstdint>
+#include <vector>
+#include <string>
+#include <istream>
+#include "NiPoint3.h"
+#include "dCommonVars.h"
+
+namespace Raw {
+
+/**
+ * @brief Flair attributes structure
+ * Represents decorative elements on the terrain
+ */
+struct FlairAttributes {
+	uint32_t id;
+	float scaleFactor;
+	NiPoint3 position;
+	NiPoint3 rotation;
+	uint8_t colorR;
+	uint8_t colorG;
+	uint8_t colorB;
+	uint8_t colorA;
+};
+
+/**
+ * @brief Mesh triangle structure
+ * Contains triangle indices for terrain mesh
+ */
+struct MeshTri {
+	uint16_t meshTriListSize;
+	std::vector<uint16_t> meshTriList;
+};
+
+/**
+ * @brief Vertex with scene ID
+ * Used for the generated terrain mesh to enable fast scene lookups
+ */
+struct SceneVertex {
+	NiPoint3 position;
+	uint8_t sceneID;
+	
+	SceneVertex() : position(), sceneID(0) {}
+	SceneVertex(const NiPoint3& pos, uint8_t scene) : position(pos), sceneID(scene) {}
+};
+
+/**
+ * @brief Generated terrain mesh
+ * Contains vertices with scene IDs for fast scene lookups at arbitrary positions
+ */
+struct TerrainMesh {
+	std::vector<SceneVertex> vertices;
+	std::vector<uint32_t> triangles; // Indices into vertices array (groups of 3)
+	
+	TerrainMesh() = default;
+};
+
+/**
+ * @brief Terrain chunk structure
+ * Represents a single chunk of terrain with heightmap, textures, and meshes
+ */
+struct Chunk {
+	uint32_t id;
+	uint32_t width;
+	uint32_t height;
+	float offsetX;
+	float offsetZ;
+	uint32_t shaderId;
+	
+	// Texture IDs (4 textures per chunk)
+	std::vector<uint32_t> textureIds;
+	
+	// Terrain scale factor
+	float scaleFactor;
+	
+	// Heightmap data (width * height floats)
+	std::vector<float> heightMap;
+	
+	// Version 32+ fields
+	uint32_t colorMapResolution = 0;
+	std::vector<uint8_t> colorMap; // RGBA pixels (colorMap * colorMap * 4)
+	std::vector<uint8_t> lightMap;
+	
+	uint32_t textureMapResolution = 0;
+	std::vector<uint8_t> textureMap; // (textureMapResolution * textureMapResolution * 4)
+	uint8_t textureSettings = 0;
+	std::vector<uint8_t> blendMap;
+	
+	// Flair data
+	std::vector<FlairAttributes> flairs;
+	
+	// Scene map (version 32+)
+	std::vector<uint8_t> sceneMap;
+	
+	// Mesh data
+	uint32_t vertSize = 0;
+	std::vector<uint16_t> meshVertUsage;
+	std::vector<uint16_t> meshVertSize;
+	std::vector<MeshTri> meshTri;
+	
+};
+
+/**
+ * @brief RAW terrain file structure
+ * Complete representation of a .raw terrain file
+ */
+struct Raw {
+	uint16_t version;
+	uint8_t dev;
+	uint32_t numChunks = 0;
+	uint32_t numChunksWidth = 0;
+	uint32_t numChunksHeight = 0;
+	std::vector<Chunk> chunks;
+	
+	// Calculated bounds of the entire terrain
+	float minBoundsX = 0.0f;
+	float minBoundsZ = 0.0f;
+	float maxBoundsX = 0.0f;
+	float maxBoundsZ = 0.0f;
+};
+
+/**
+ * @brief Read a RAW terrain file from an input stream
+ * 
+ * @param stream Input stream containing RAW file data
+ * @param outRaw Output RAW file structure
+ * @return true if successfully read, false otherwise
+ */
+bool ReadRaw(std::istream& stream, Raw& outRaw);
+
+/**
+ * @brief Generate a terrain mesh from raw chunks
+ * Similar to dTerrain's GenerateFinalMeshFromChunks but creates a mesh with scene IDs
+ * per vertex for fast scene lookups at arbitrary positions.
+ * 
+ * @param raw The RAW terrain data to generate mesh from
+ * @param outMesh Output terrain mesh with vertices and scene IDs
+ */
+void GenerateTerrainMesh(const Raw& raw, TerrainMesh& outMesh);
+
+/**
+ * @brief Write terrain mesh to OBJ file for debugging/visualization
+ * Merged from dTerrain's WriteFinalMeshToOBJ functionality
+ * Vertices are colored based on their scene ID using a hash function
+ * 
+ * @param mesh The terrain mesh to export
+ * @param path Output path for the OBJ file
+ * @return true if successfully written, false otherwise
+ */
+bool WriteTerrainMeshToOBJ(const TerrainMesh& mesh, const std::string& path);
+
+} // namespace Raw
+
+#endif // __RAW_H__

dZoneManager/Zone.cpp

@@ -8,6 +8,7 @@
 #include "GeneralUtils.h"
 #include "BinaryIO.h"
 #include "LUTriggers.h"
+#include "dConfig.h"
 
 #include "AssetManager.h"
 #include "CDClientManager.h"
@@ -20,6 +21,7 @@
 #include "eTriggerEventType.h"
 #include "eWaypointCommandType.h"
 #include "dNavMesh.h"
+#include "Raw.h"
 
 Zone::Zone(const LWOZONEID zoneID) :
 	m_ZoneID(zoneID) {
@@ -78,12 +80,51 @@ void Zone::LoadZoneIntoMemory() {
 			LoadScene(file);
 		}
 
-		//Read generic zone info:
-		BinaryIO::ReadString<uint8_t>(file, m_ZonePath, BinaryIO::ReadType::String);
+		// Zone boundary lines — skip past them for correct file positioning
+		uint8_t numBoundaries = 0;
+		BinaryIO::BinaryRead(file, numBoundaries);
+		for (uint8_t i = 0; i < numBoundaries; ++i) {
+			NiPoint3 normal, point, spawnLocation;
+			uint32_t packed, destSceneID;
+			BinaryIO::BinaryRead(file, normal);
+			BinaryIO::BinaryRead(file, point);
+			BinaryIO::BinaryRead(file, packed);
+			BinaryIO::BinaryRead(file, destSceneID);
+			BinaryIO::BinaryRead(file, spawnLocation);
+		}
+
 		BinaryIO::ReadString<uint8_t>(file, m_ZoneRawPath, BinaryIO::ReadType::String);
 		BinaryIO::ReadString<uint8_t>(file, m_ZoneName, BinaryIO::ReadType::String);
 		BinaryIO::ReadString<uint8_t>(file, m_ZoneDesc, BinaryIO::ReadType::String);
 
+		auto zoneFolderPath = m_ZoneFilePath.substr(0, m_ZoneFilePath.rfind('/') + 1);
+		if (!Game::assetManager->HasFile(zoneFolderPath + m_ZoneRawPath)) {
+			LOG("Failed to find %s", (zoneFolderPath + m_ZoneRawPath).c_str());
+			throw std::runtime_error("Aborting Zone loading due to no Zone Raw File.");
+		}
+
+		auto rawFile = Game::assetManager->GetFile(zoneFolderPath + m_ZoneRawPath);
+		if (!Raw::ReadRaw(rawFile, m_Raw)) {
+			LOG("Failed to parse %s", (zoneFolderPath + m_ZoneRawPath).c_str());
+			throw std::runtime_error("Aborting Zone loading due to invalid Raw File.");
+		}
+		LOG("Loaded Raw Terrain with %u chunks", m_Raw.numChunks);
+
+
+		// Optionally export terrain mesh to OBJ for debugging/visualization
+		if (Game::config->GetValue("export_terrain_to_obj") == "1") {
+
+			// Generate terrain mesh
+			Raw::GenerateTerrainMesh(m_Raw, m_TerrainMesh);
+			LOG("Generated terrain mesh with %zu vertices and %zu triangles", m_TerrainMesh.vertices.size(), m_TerrainMesh.triangles.size() / 3);
+
+			// Write to OBJ
+			std::string objFileName = "terrain_" + std::to_string(m_ZoneID.GetMapID()) + ".obj";
+			if (Raw::WriteTerrainMeshToOBJ(m_TerrainMesh, objFileName)) {
+				LOG("Exported terrain mesh to %s", objFileName.c_str());
+			}
+		}
+
 		if (m_FileFormatVersion >= Zone::FileFormatVersion::PreAlpha) {
 			BinaryIO::BinaryRead(file, m_NumberOfSceneTransitionsLoaded);
 			for (uint32_t i = 0; i < m_NumberOfSceneTransitionsLoaded; ++i) {
@@ -236,20 +277,23 @@ void Zone::LoadScene(std::istream& file) {
 	}
 	if (m_FileFormatVersion >= Zone::FileFormatVersion::LatePreAlpha) {
 		BinaryIO::BinaryRead(file, scene.sceneType);
-		lwoSceneID.SetLayerID(scene.sceneType);
+		lwoSceneID.SetLayerID(static_cast<uint32_t>(scene.sceneType));
+
 
 		BinaryIO::ReadString<uint8_t>(file, scene.name, BinaryIO::ReadType::String);
 	}
 
 	if (m_FileFormatVersion == Zone::FileFormatVersion::LatePreAlpha) {
-		BinaryIO::BinaryRead(file, scene.unknown1);
-		BinaryIO::BinaryRead(file, scene.unknown2);
+		BinaryIO::BinaryRead(file, scene.scenePosition);
+		BinaryIO::BinaryRead(file, scene.sceneRadius);
 	}
 
 	if (m_FileFormatVersion >= Zone::FileFormatVersion::LatePreAlpha) {
-		BinaryIO::BinaryRead(file, scene.color_r);
-		BinaryIO::BinaryRead(file, scene.color_b);
-		BinaryIO::BinaryRead(file, scene.color_g);
+		uint8_t r, b, g;
+		BinaryIO::BinaryRead(file, r);
+		BinaryIO::BinaryRead(file, b);
+		BinaryIO::BinaryRead(file, g);
+		scene.color = NiColor(r / 255.0f, g / 255.0f, b / 255.0f);
 	}
 
 	m_Scenes[lwoSceneID] = std::move(scene);
@@ -350,7 +394,10 @@ void Zone::LoadSceneTransition(std::istream& file) {
 
 SceneTransitionInfo Zone::LoadSceneTransitionInfo(std::istream& file) {
 	SceneTransitionInfo info;
-	BinaryIO::BinaryRead(file, info.sceneID);
+	uint32_t sceneID, layerID;
+	BinaryIO::BinaryRead(file, sceneID);
+	BinaryIO::BinaryRead(file, layerID);
+	info.sceneID = LWOSCENEID(static_cast<int32_t>(sceneID), layerID);
 	BinaryIO::BinaryRead(file, info.position);
 	return info;
 }
@@ -422,7 +469,6 @@ void Zone::LoadPath(std::istream& file) {
 		BinaryIO::BinaryRead(file, waypoint.position.y);
 		BinaryIO::BinaryRead(file, waypoint.position.z);
 
-
 		if (path.pathType == PathType::Spawner || path.pathType == PathType::MovingPlatform || path.pathType == PathType::Race || path.pathType == PathType::Camera || path.pathType == PathType::Rail) {
 			BinaryIO::BinaryRead(file, waypoint.rotation.w);
 			BinaryIO::BinaryRead(file, waypoint.rotation.x);
@@ -483,7 +529,7 @@ void Zone::LoadPath(std::istream& file) {
 		}
 
 		// We verify the waypoint heights against the navmesh because in many movement paths,
-		// the waypoint is located near 0 height, 
+		// the waypoint is located near 0 height,
 		if (path.pathType == PathType::Movement) {
 			if (dpWorld::IsLoaded()) {
 				// 2000 should be large enough for every world.
@@ -494,3 +540,9 @@ void Zone::LoadPath(std::istream& file) {
 	}
 	m_Paths.push_back(path);
 }
+
+const SceneRef* Zone::GetScene(LWOSCENEID sceneID) const {
+	auto it = m_Scenes.find(sceneID);
+	if (it != m_Scenes.end()) return &it->second;
+	return nullptr;
+}

dZoneManager/Zone.h

@@ -2,10 +2,12 @@
 
 #include "dZMCommon.h"
 #include "LDFFormat.h"
+#include "NiColor.h"
 #include "tinyxml2.h"
 #include <string>
 #include <vector>
 #include <map>
+#include "Raw.h"
 
 namespace LUTriggers {
 	struct Trigger;
@@ -21,22 +23,25 @@ struct WaypointCommand {
 };
 
 
+enum class eSceneType : uint32_t {
+	General = 0,
+	Audio = 1,
+};
+
 struct SceneRef {
 	std::string filename;
 	uint32_t id{};
-	uint32_t sceneType{}; //0 = general, 1 = audio?
+	eSceneType sceneType{};
 	std::string name;
-	NiPoint3 unknown1;
-	float unknown2{};
-	uint8_t color_r{};
-	uint8_t color_g{};
-	uint8_t color_b{};
+	NiPoint3 scenePosition;   // version 33 only: editor bounding sphere center
+	float sceneRadius{};      // version 33 only: editor bounding sphere radius
+	NiColor color;
 	std::unique_ptr<Level> level;
 	std::map<uint32_t, LUTriggers::Trigger*> triggers;
 };
 
 struct SceneTransitionInfo {
-	uint64_t sceneID{}; //id of the scene being transitioned to.
+	LWOSCENEID sceneID;
 	NiPoint3 position;
 };
 
@@ -228,6 +233,12 @@ public:
 	void SetSpawnPos(const NiPoint3& pos) { m_Spawnpoint = pos; }
 	void SetSpawnRot(const NiQuaternion& rot) { m_SpawnpointRotation = rot; }
 
+	const Raw::Raw& GetZoneRaw() const { return m_Raw; }
+	const Raw::TerrainMesh& GetTerrainMesh() const { return m_TerrainMesh; }
+	const SceneRef* GetScene(LWOSCENEID sceneID) const;
+	const std::vector<SceneTransition>& GetSceneTransitions() const { return m_SceneTransitions; }
+	const std::map<LWOSCENEID, SceneRef>& GetScenes() const { return m_Scenes; }
+
 private:
 	LWOZONEID m_ZoneID;
 	std::string m_ZoneFilePath;
@@ -244,6 +255,8 @@ private:
 	std::string m_ZoneName; //Name given to the zone by a level designer
 	std::string m_ZoneDesc; //Description of the zone by a level designer
 	std::string m_ZoneRawPath; //Path to the .raw file of this zone.
+	Raw::Raw m_Raw; // The Raw data for this zone
+	Raw::TerrainMesh m_TerrainMesh; // Pre-generated terrain mesh for fast scene lookups
 
 	std::map<LWOSCENEID, SceneRef> m_Scenes;
 	std::vector<SceneTransition> m_SceneTransitions;

dZoneManager/dZoneManager.cpp

@@ -10,9 +10,11 @@
 #include "VanityUtilities.h"
 #include "WorldConfig.h"
 #include "CDZoneTableTable.h"
+#include <algorithm>
 #include <chrono>
+#include <cmath>
+#include <set>
 #include "eObjectBits.h"
-#include "CDZoneTableTable.h"
 #include "AssetManager.h"
 #include <ranges>
 
@@ -62,6 +64,9 @@ void dZoneManager::Initialize(const LWOZONEID& zoneID) {
 
 	m_pZone->Initalize();
 
+	// Build the scene graph after zone is loaded
+	BuildSceneGraph();
+
 	endTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
 
 	LoadWorldConfig();
@@ -298,3 +303,131 @@ void dZoneManager::LoadWorldConfig() {
 
 	LOG_DEBUG("Loaded WorldConfig into memory");
 }
+
+LWOSCENEID dZoneManager::GetSceneIDFromPosition(const NiPoint3& position) const {
+	if (!m_pZone) return LWOSCENEID_INVALID;
+
+	const auto& raw = m_pZone->GetZoneRaw();
+	
+	// If no chunks, no scene data available
+	if (raw.chunks.empty()) {
+		return LWOSCENEID_INVALID;
+	}
+
+	// Convert 3D position to 2D (XZ plane) and clamp to terrain bounds
+	float posX = std::clamp(position.x, raw.minBoundsX, raw.maxBoundsX);
+	float posZ = std::clamp(position.z, raw.minBoundsZ, raw.maxBoundsZ);
+
+	// Find the chunk containing this position
+	// Reverse the world position calculation from GenerateTerrainMesh
+	for (const auto& chunk : raw.chunks) {
+		if (chunk.sceneMap.empty() || chunk.scaleFactor <= 0.0f || chunk.width <= 1 || chunk.height <= 1 || chunk.colorMapResolution == 0) continue;
+
+		// Reverse: worldX = (i + offsetX/scaleFactor) * scaleFactor
+		// Therefore: i = worldX/scaleFactor - offsetX/scaleFactor
+		const float heightI = posX / chunk.scaleFactor - (chunk.offsetX / chunk.scaleFactor);
+		const float heightJ = posZ / chunk.scaleFactor - (chunk.offsetZ / chunk.scaleFactor);
+
+		// Check if position is within this chunk's heightmap bounds
+		if (heightI >= 0.0f && heightI < static_cast<float>(chunk.width) &&
+			heightJ >= 0.0f && heightJ < static_cast<float>(chunk.height)) {
+			
+			const float sceneMapI = (heightI / static_cast<float>(chunk.width - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
+			const float sceneMapJ = (heightJ / static_cast<float>(chunk.height - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
+
+			const uint32_t sceneI = std::min(static_cast<uint32_t>(sceneMapI), chunk.colorMapResolution - 1);
+			const uint32_t sceneJ = std::min(static_cast<uint32_t>(sceneMapJ), chunk.colorMapResolution - 1);
+
+			// Scene map uses the same indexing pattern as heightmap: row * width + col
+			const uint32_t sceneIndex = sceneI * chunk.colorMapResolution + sceneJ;
+
+			// Bounds check: if this chunk's sceneMap is inconsistent, skip this chunk
+			if (sceneIndex >= chunk.sceneMap.size()) {
+				LOG_DEBUG("GetSceneIDFromPosition: sceneIndex %u out of bounds (sceneMap size: %zu), skipping malformed chunk.", sceneIndex, chunk.sceneMap.size());
+				continue;
+			}
+
+			// Get scene ID from sceneMap
+			const uint8_t sceneID = chunk.sceneMap[sceneIndex];
+			
+			// Return the scene ID
+			return LWOSCENEID(sceneID, 0);
+		}
+	}
+
+	// Position not found in any chunk
+	return LWOSCENEID_INVALID;
+}
+
+void dZoneManager::BuildSceneGraph() {
+	if (!m_pZone) return;
+
+	// Clear any existing adjacency list
+	m_SceneAdjacencyList.clear();
+
+	// Initialize adjacency list with all scenes
+	const auto& scenes = m_pZone->GetScenes();
+	for (const auto& [sceneID, sceneRef] : scenes) {
+		if (sceneRef.sceneType != eSceneType::General) continue;
+		m_SceneAdjacencyList.try_emplace(sceneID, std::vector<LWOSCENEID>());
+	}
+
+	// Build adjacency list from scene transitions
+	const auto& transitions = m_pZone->GetSceneTransitions();
+	for (const auto& transition : transitions) {
+		// Each transition has multiple points, each pointing to a scene
+		// We need to determine which scenes this transition connects
+		
+		// Group transition points by their scene IDs to find unique connections
+		std::set<LWOSCENEID> connectedScenes;
+		for (const auto& point : transition.points) {
+			if (point.sceneID != LWOSCENEID_INVALID && m_SceneAdjacencyList.contains(point.sceneID)) {
+				connectedScenes.insert(point.sceneID);
+			}
+		}
+
+		// Create bidirectional edges between all scenes in this transition
+		// (transitions typically connect two scenes, but can be more complex)
+		std::vector<LWOSCENEID> sceneList(connectedScenes.begin(), connectedScenes.end());
+		
+		for (size_t i = 0; i < sceneList.size(); ++i) {
+			for (size_t j = 0; j < sceneList.size(); ++j) {
+				if (i != j) {
+					LWOSCENEID fromScene = sceneList[i];
+					LWOSCENEID toScene = sceneList[j];
+					
+					// Add edge if it doesn't already exist
+					auto& adjacentScenes = m_SceneAdjacencyList[fromScene];
+					if (std::find(adjacentScenes.begin(), adjacentScenes.end(), toScene) == adjacentScenes.end()) {
+						adjacentScenes.push_back(toScene);
+					}
+				}
+			}
+		}
+	}
+	
+	// Scene 0 (global scene) is always loaded and adjacent to all other scenes
+	LWOSCENEID globalScene = LWOSCENEID(0, 0);
+	for (auto& [sceneID, adjacentScenes] : m_SceneAdjacencyList) {
+		if (sceneID != globalScene) {
+			// Add global scene to this scene's adjacency list if not already present
+			if (std::find(adjacentScenes.begin(), adjacentScenes.end(), globalScene) == adjacentScenes.end()) {
+				adjacentScenes.push_back(globalScene);
+			}
+			
+			// Add this scene to global scene's adjacency list if not already present
+			auto& globalAdjacent = m_SceneAdjacencyList[globalScene];
+			if (std::find(globalAdjacent.begin(), globalAdjacent.end(), sceneID) == globalAdjacent.end()) {
+				globalAdjacent.push_back(sceneID);
+			}
+		}
+	}
+}
+
+std::vector<LWOSCENEID> dZoneManager::GetAdjacentScenes(LWOSCENEID sceneID) const {
+	auto it = m_SceneAdjacencyList.find(sceneID);
+	if (it != m_SceneAdjacencyList.end()) {
+		return it->second;
+	}
+	return std::vector<LWOSCENEID>();
+}

dZoneManager/dZoneManager.h

@@ -53,6 +53,30 @@ public:
 	uint32_t GetUniqueMissionIdStartingValue();
 	bool CheckIfAccessibleZone(LWOMAPID zoneID);
 
+	/**
+	 * @brief Get the scene ID at a given position. Scenes do not care about height (Y coordinate).
+	 * 
+	 * @param position The position to query
+	 * @return The scene ID at that position, or LWOSCENEID_INVALID if not found
+	 */
+	LWOSCENEID GetSceneIDFromPosition(const NiPoint3& position) const;
+
+	/**
+	 * @brief Get the adjacency list for the scene graph.
+	 * The adjacency list maps each scene ID to a list of scene IDs it can transition to.
+	 * 
+	 * @return A reference to the scene adjacency list
+	 */
+	const std::map<LWOSCENEID, std::vector<LWOSCENEID>>& GetSceneAdjacencyList() const { return m_SceneAdjacencyList; }
+
+	/**
+	 * @brief Get all scenes adjacent to (connected to) a given scene.
+	 * 
+	 * @param sceneID The scene ID to query
+	 * @return A vector of scene IDs that are directly connected to this scene, or empty vector if scene not found
+	 */
+	std::vector<LWOSCENEID> GetAdjacentScenes(LWOSCENEID sceneID) const;
+
 	// The world config should not be modified by a caller.
 	const WorldConfig& GetWorldConfig() {
 		if (!m_WorldConfig) LoadWorldConfig();
@@ -60,6 +84,10 @@ public:
 	};
 
 private:
+	/**
+	 * Builds the scene graph adjacency list from scene transitions
+	 */
+	void BuildSceneGraph();
 	/**
 	 * The starting unique mission ID.
 	 */
@@ -75,4 +103,9 @@ private:
 	std::optional<WorldConfig> m_WorldConfig = std::nullopt;
 
 	Entity* m_ZoneControlObject = nullptr;
+
+	/**
+	 * Scene graph adjacency list: maps each scene ID to a list of scenes it can transition to
+	 */
+	std::map<LWOSCENEID, std::vector<LWOSCENEID>> m_SceneAdjacencyList;
 };