fix: read a scene file's chunks, environment and objects as the client does

The world read only a scene's objects and skipped the rest with
file.ignore. Level now reads a .lvl the way SceneLoader::LoadLvlFile
does (1.10.64) and keeps what it reads.

Chunked files: the file info chunk gives where the environment, object
and particle chunks start (the chunks were walked in order before); the
environment chunk gives where the lighting, skydome and editor settings
start, and the client reads all three only when there is lighting.

Files from before chunks: the no-editor-settings byte only from version
32, the revision from 37, a file newer than 48 is not read, a file
older than 3 has no objects; then lighting, skydome, editor settings
and objects in turn.

Kept, by version:
- lighting: blend time (45 on, default 10), ambient, specular, upper
  hemisphere, position, min and max draw distances (31 on; before 39
  fog near and far only), cull settings (40 on), fog colour (31 on),
  directional colour (36 on), and before 42 the zone's spawn point
  (before 33 the fixed one the client uses);
- the skydome and its five other files (34 on; they were skipped from
  33);
- the editor's colours (37 on, the first 32);
- each object's node type (38 on), glom ID (32 on) and render
  techniques (7 on: a 64 byte name, then per technique a 64 byte name,
  u32, u8 and 16 floats); before, a count of techniques was read and
  the techniques themselves were not, so an object with any misread
  the rest of the file.

Object config is split at line breaks as before. A file that ends early
keeps the objects read before its end.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

dCommon/LevelFile.h

@@ -1,31 +1,89 @@
 #pragma once
 
+#include <array>
 #include <cstdint>
 #include <iosfwd>
 #include <map>
+#include <string>
 #include <vector>
 
 #include "dCommonVars.h"
+#include "NiColor.h"
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "LDFFormat.h"
 
+// One of an object's render techniques (SceneLoader::ReadLvlObjectData, version 7 on)
+struct LevelRenderTechnique {
+	std::string name; // 64 bytes in the file
+	uint32_t valueCount{};
+	uint8_t isColor{};
+	std::array<float, 16> values{};
+};
+
 struct SceneObject {
-	LWOOBJID id;
-	LOT lot;
+	LWOOBJID id{};
+	LOT lot{};
 	uint32_t nodeType = 1; // the client's default when the file has none, or one outside 0-10
 	uint32_t glomId = 1;
 	NiPoint3 position;
 	NiQuaternion rotation = QuatUtils::IDENTITY;
 	float scale = 1.0f;
-	uint32_t renderTechniqueCount{};
+	std::string renderTechniquesName; // 64 bytes in the file, only there when there are render techniques
+	std::vector<LevelRenderTechnique> renderTechniques;
 	LwoNameValue settings;
 };
 
+// Fog and object draw distances (SceneDrawDistances); -1 is the client's default for a value the file doesn't have
+struct SceneDrawDistances {
+	float fogNear = -1.0f;
+	float fogFar = -1.0f;
+	float postFogSolid = -1.0f;
+	float postFogFade = -1.0f;
+	float staticObjectDistance = -1.0f;
+	float dynamicObjectDistance = -1.0f;
+};
+
+// The draw distances of a group of objects (version 40 on)
+struct SceneCullSetting {
+	uint32_t group{};
+	float minDistance{};
+	float maxDistance{};
+};
+
+// A scene's light environment (SceneLoader::ReadLightingInfo); the defaults are the client's for what older files don't have
+struct LevelLighting {
+	float blendTime = 10.0f; // version 45 on
+	NiColor ambient;
+	NiColor specular;
+	NiColor upperHemi;
+	NiPoint3 position;
+	// Version 31 on; before 39 only the fog distances, the same in both
+	SceneDrawDistances minDrawDistances;
+	SceneDrawDistances maxDrawDistances;
+	std::vector<SceneCullSetting> cullSettings; // version 40 on
+	NiColor fogColor{ 0.75f, 0.88f, 0.91f }; // version 31 on
+	NiColor directional; // version 36 on
+
+	// Before version 42 the zone's spawn point is here. Before 33 the file has only a position, which the client
+	// ignores: it uses a fixed spawn point instead
+	bool hasSpawnPoint = false;
+	NiPoint3 filePosition;
+	NiPoint3 spawnPosition;
+	NiQuaternion spawnRotation = QuatUtils::IDENTITY;
+};
+
+// The skydome's file and five more (version 34 on) the client reads and doesn't use (SceneLoader::ReadSkydomeInfo)
+struct LevelSkydome {
+	std::string filename;
+	std::array<std::string, 5> extraFilenames;
+};
+
 /**
- * A scene file (.lvl) as the world server loads it (Level): its chunk headers and every object in it, with the object's
- * settings parsed. Only reads; which objects the world spawns (feature gating, client-only objects, spawners) stays in
- * dZoneManager, so the dashboard reads scenes with the same code.
+ * A scene file (.lvl), read as the client reads it (SceneLoader::LoadLvlFile): its chunk headers, environment, every
+ * object in it with the object's settings parsed. Only reads; which objects the world
+ * spawns (feature gating, client-only objects, spawners) stays in dZoneManager, so the dashboard reads scenes with the
+ * same code.
  */
 struct LevelFile {
 	enum ChunkTypeID : uint16_t {
@@ -52,7 +110,26 @@ struct LevelFile {
 		FileInfoChunk fileInfo;
 	};
 
+	// The environment chunk: where its parts start in the file (0 for none)
+	struct EnviromentChunk {
+		uint32_t lightingStart{};
+		uint32_t skydomeStart{};
+		uint32_t editorSettingsStart{};
+	};
+
 	std::map<uint32_t, ChunkHeader> chunkHeaders;
+
+	// The file's version: from the file info chunk, or the header of a file from before chunks
+	uint32_t version{};
+	uint32_t revision{};
+	// Before chunks, from version 32: set when the file has no editor settings
+	uint8_t noEditorSettings{};
+	EnviromentChunk enviroment;
+	bool hasLighting = false;
+	LevelLighting lighting;
+	LevelSkydome skydome;
+	// Version 37 on: the editor's saved colours (the client keeps at most 32)
+	std::vector<NiColor> editorColors;
 	std::vector<SceneObject> objects;
 
 	/**
@@ -64,6 +141,8 @@ struct LevelFile {
 private:
 	static ChunkHeader ReadChunkHeader(std::istream& file, uint32_t start);
 	void ReadFileInfoChunk(std::istream& file, ChunkHeader& header);
-	void ReadSceneObjectDataChunk(std::istream& file, uint32_t version);
-	static void ApplyClientConfigFixups(SceneObject& obj, uint32_t version);
+	void ReadLightingInfo(std::istream& file);
+	void ReadSkydomeInfo(std::istream& file);
+	void ReadEditorSettings(std::istream& file);
+	void ReadSceneObjectDataChunk(std::istream& file);
 };