Implement comprehensive taxi flight optimizations and proper spline paths

Major improvements:
- Load TaxiPathNode.dbc for actual curved flight paths (no more flying through terrain)
- Add 3-second mounting delay with terrain precaching for entire route
- Implement LOD system for M2 models with distance-based quality reduction
- Add circular terrain loading pattern (13 tiles vs 25, 48% reduction)
- Increase terrain cache from 2GB to 8GB for modern systems

Performance optimizations during taxi:
- Cull small M2 models (boundRadius < 3.0) - not visible from altitude
- Disable particle systems (weather, smoke, M2 emitters) - saves ~7000 particles
- Disable specular lighting on M2 models - saves Blinn-Phong calculations
- Disable shadow mapping on M2 models - saves shadow map sampling and PCF

Technical details:
- Parse TaxiPathNode.dbc spline waypoints for curved paths around terrain
- Build full path from node pairs using TaxiPathEdge lookup
- Precache callback triggers during mounting delay for smooth takeoff
- Circular tile loading uses Euclidean distance check (dx²+dy² <= r²)
- LOD fallback to base mesh when higher LODs unavailable

Result: Buttery smooth taxi flights with no terrain clipping or performance hitches

include/game/game_handler.hpp

@@ -496,6 +496,11 @@ public:
     // Mount state
     using MountCallback = std::function<void(uint32_t mountDisplayId)>;  // 0 = dismount
     void setMountCallback(MountCallback cb) { mountCallback_ = std::move(cb); }
+
+    // Taxi terrain precaching callback
+    using TaxiPrecacheCallback = std::function<void(const std::vector<glm::vec3>&)>;
+    void setTaxiPrecacheCallback(TaxiPrecacheCallback cb) { taxiPrecacheCallback_ = std::move(cb); }
+
     bool isMounted() const { return currentMountDisplayId_ != 0; }
     bool isHostileAttacker(uint64_t guid) const { return hostileAttackers_.count(guid) > 0; }
     float getServerRunSpeed() const { return serverRunSpeed_; }
@@ -522,6 +527,13 @@ public:
         uint32_t fromNode = 0, toNode = 0;
         uint32_t cost = 0;
     };
+    struct TaxiPathNode {
+        uint32_t id = 0;
+        uint32_t pathId = 0;
+        uint32_t nodeIndex = 0;
+        uint32_t mapId = 0;
+        float x = 0, y = 0, z = 0;
+    };
     const std::unordered_map<uint32_t, TaxiNode>& getTaxiNodes() const { return taxiNodes_; }
     uint32_t getTaxiCostTo(uint32_t destNodeId) const;
 
@@ -934,6 +946,7 @@ private:
     // Taxi / Flight Paths
     std::unordered_map<uint32_t, TaxiNode> taxiNodes_;
     std::vector<TaxiPathEdge> taxiPathEdges_;
+    std::unordered_map<uint32_t, std::vector<TaxiPathNode>> taxiPathNodes_;  // pathId -> ordered waypoints
     bool taxiDbcLoaded_ = false;
     bool taxiWindowOpen_ = false;
     ShowTaxiNodesData currentTaxiData_;
@@ -948,6 +961,9 @@ private:
     std::vector<glm::vec3> taxiClientPath_;
     float taxiClientSpeed_ = 32.0f;
     float taxiClientSegmentProgress_ = 0.0f;
+    bool taxiMountingDelay_ = false;  // Delay before flight starts (terrain precache time)
+    float taxiMountingTimer_ = 0.0f;
+    std::vector<uint32_t> taxiPendingPath_;  // Path nodes waiting for mounting delay
     bool taxiRecoverPending_ = false;
     uint32_t taxiRecoverMapId_ = 0;
     glm::vec3 taxiRecoverPos_{0.0f};
@@ -1006,6 +1022,7 @@ private:
     MeleeSwingCallback meleeSwingCallback_;
     NpcSwingCallback npcSwingCallback_;
     MountCallback mountCallback_;
+    TaxiPrecacheCallback taxiPrecacheCallback_;
     uint32_t currentMountDisplayId_ = 0;
     float serverRunSpeed_ = 7.0f;
     bool playerDead_ = false;

include/rendering/camera_controller.hpp

@@ -76,6 +76,7 @@ public:
     bool isSitting() const { return sitting; }
     bool isSwimming() const { return swimming; }
     bool isInsideWMO() const { return cachedInsideWMO; }
+    bool isOnTaxi() const { return externalFollow_; }
     const glm::vec3* getFollowTarget() const { return followTarget; }
     glm::vec3* getFollowTargetMutable() { return followTarget; }
 

include/rendering/m2_renderer.hpp

@@ -35,6 +35,7 @@ struct M2ModelGPU {
         uint16_t textureAnimIndex = 0xFFFF; // 0xFFFF = no texture animation
         uint16_t blendMode = 0;   // 0=Opaque, 1=AlphaKey, 2=Alpha, 3=Add, etc.
         uint16_t materialFlags = 0; // M2 material flags (0x01=Unlit, 0x04=TwoSided, 0x10=NoDepthWrite)
+        uint16_t submeshLevel = 0; // LOD level: 0=base, 1=LOD1, 2=LOD2, 3=LOD3
         glm::vec3 center = glm::vec3(0.0f); // Center of batch geometry (model space)
         float glowSize = 1.0f;              // Approx radius of batch geometry
     };
@@ -58,6 +59,7 @@ struct M2ModelGPU {
     bool collisionTreeTrunk = false;
     bool collisionNoBlock = false;
     bool collisionStatue = false;
+    bool isSmallFoliage = false;  // Small foliage (bushes, grass, plants) - skip during taxi
 
     // Collision mesh with spatial grid (from M2 bounding geometry)
     struct CollisionMesh {
@@ -310,9 +312,11 @@ public:
     void clearShadowMap() { shadowEnabled = false; }
 
     void setInsideInterior(bool inside) { insideInterior = inside; }
+    void setOnTaxi(bool onTaxi) { onTaxi_ = onTaxi; }
 
 private:
     bool insideInterior = false;
+    bool onTaxi_ = false;
     pipeline::AssetManager* assetManager = nullptr;
     std::unique_ptr<Shader> shader;
 

include/rendering/terrain_manager.hpp

@@ -166,6 +166,12 @@ public:
      */
     void unloadAll();
 
+    /**
+     * Precache a set of tiles (for taxi routes, etc.)
+     * @param tiles Vector of (x, y) tile coordinates to preload
+     */
+    void precacheTiles(const std::vector<std::pair<int, int>>& tiles);
+
     /**
      * Set streaming parameters
      */
@@ -294,7 +300,7 @@ private:
     std::unordered_map<TileCoord, CachedTile, TileCoord::Hash> tileCache_;
     std::list<TileCoord> tileCacheLru_;
     size_t tileCacheBytes_ = 0;
-    size_t tileCacheBudgetBytes_ = 2ull * 1024 * 1024 * 1024; // 2GB default
+    size_t tileCacheBudgetBytes_ = 8ull * 1024 * 1024 * 1024; // 8GB for modern systems
     std::mutex tileCacheMutex_;
 
     std::shared_ptr<PendingTile> getCachedTile(const TileCoord& coord);