Major clean up

src/planet/PlanetData.cpp

@@ -1,4 +1,4 @@
-#include "PlanetData.h"
+#include "PlanetData.h"
 #include <iostream>
 #include <numeric>
 #include <cmath>
@@ -10,13 +10,13 @@ namespace ZL {
     const float PlanetData::PLANET_RADIUS = 20000.f;
     const Vector3f PlanetData::PLANET_CENTER_OFFSET = Vector3f{ 0.f, 0.f, 0.0f };
 
-    // --- Êîíñòàíòû äèàïàçîíîâ (ïåðåíåñåíû èç PlanetObject.cpp) ---
+    // --- Константы диапазонов (перенесены из PlanetObject.cpp) ---
 
     VertexID generateEdgeID(const VertexID& id1, const VertexID& id2) {
         return id1 < id2 ? id1 + "_" + id2 : id2 + "_" + id1;
     }
 
-    // Âñïîìîãàòåëüíàÿ ôóíêöèÿ äëÿ ïðîåêöèè (ëîêàëüíàÿ)
+    // Вспомогательная функция для проекции (локальная)
     static Vector3f projectPointOnPlane(const Vector3f& P, const Vector3f& A, const Vector3f& B, const Vector3f& C) {
         Vector3f AB = B + A * (-1.0f);
         Vector3f AC = C + A * (-1.0f);
@@ -138,18 +138,18 @@ namespace ZL {
 
 
     std::vector<int> PlanetData::getBestTriangleUnderCamera(const Vector3f& viewerPosition) {
-        const LodLevel& finalLod = planetMeshLods[currentLod]; // Ðàáîòàåì ñ òåêóùèì àêòèâíûì LOD
+        const LodLevel& finalLod = planetMeshLods[currentLod]; // Работаем с текущим активным LOD
         Vector3f targetDir = (viewerPosition - PLANET_CENTER_OFFSET).normalized();
 
         int bestTriangle = -1;
         float maxDot = -1.0f;
 
-        // Øàã 1: Áûñòðûé ïîèñê áëèæàéøåãî òðåóãîëüíèêà ïî "öåíòðîèäó"
-        // ×òîáû íå ïðîâåðÿòü âñå, ìîæíî ïðîâåðÿòü êàæäûé N-é èëè èñïîëüçîâàòü 
-        // ïðåäâàðèòåëüíî âû÷èñëåííûå öåíòðû äëÿ LOD0, ÷òîáû ñóçèòü êðóã.
-        // Íî äëÿ íàäåæíîñòè ïðîéäåìñÿ ïî ìàññèâó (äëÿ 5-6 ïîäðàçäåëåíèé ýòî áûñòðî)
+        // Шаг 1: Быстрый поиск ближайшего треугольника по "центроиду"
+        // Чтобы не проверять все, можно проверять каждый N-й или использовать 
+        // предварительно вычисленные центры для LOD0, чтобы сузить круг.
+        // Но для надежности пройдемся по массиву (для 5-6 подразделений это быстро)
         for (int i = 0; i < (int)finalLod.triangles.size(); ++i) {
-            // Âû÷èñëÿåì ïðèìåðíîå íàïðàâëåíèå íà òðåóãîëüíèê
+            // Вычисляем примерное направление на треугольник
             Vector3f triDir = (finalLod.triangles[i].data[0] +
                 finalLod.triangles[i].data[1] +
                 finalLod.triangles[i].data[2]).normalized();
@@ -172,22 +172,22 @@ namespace ZL {
         float currentDist = shipLocal.norm();
         Vector3f targetDir = shipLocal.normalized();
 
-        // Æåëàåìûé ðàäèóñ ïîêðûòèÿ íà ïîâåðõíîñòè ïëàíåòû (â ìåòðàõ/åäèíèöàõ äâèæêà)
-        // Ïîäáåðè ýòî çíà÷åíèå òàê, ÷òîáû êàìíè âîêðóã êîðàáëÿ âñåãäà áûëè âèäíû.
+        // Желаемый радиус покрытия на поверхности планеты (в метрах/единицах движка)
+        // Подбери это значение так, чтобы камни вокруг корабля всегда были видны.
         const float desiredCoverageRadius = 3000.0f;
 
-        // Âû÷èñëÿåì ïîðîã êîñèíóñà íà îñíîâå æåëàåìîãî ðàäèóñà è òåêóùåãî ðàññòîÿíèÿ.
-        // ×åì ìû äàëüøå (currentDist áîëüøå), òåì ìåíüøå äîëæåí áûòü óãîë îòêëîíåíèÿ 
-        // îò íîðìàëè, ÷òîáû çàõâàòèòü òó æå ïëîùàäü.
+        // Вычисляем порог косинуса на основе желаемого радиуса и текущего расстояния.
+        // Чем мы дальше (currentDist больше), тем меньше должен быть угол отклонения 
+        // от нормали, чтобы захватить ту же площадь.
         float angle = atan2(desiredCoverageRadius, currentDist);
         float searchThreshold = cos(angle);
 
-        // Îãðàíè÷èòåëü, ÷òîáû íå çàõâàòèòü âñþ ïëàíåòó èëè âîîáùå íè÷åãî
+        // Ограничитель, чтобы не захватить всю планету или вообще ничего
         searchThreshold = std::clamp(searchThreshold, 0.90f, 0.9999f);
 
         std::vector<int> result;
         for (int i = 0; i < (int)finalLod.triangles.size(); ++i) {
-            // Èñïîëüçóåì öåíòðîèä (ìîæíî êýøèðîâàòü â LodLevel äëÿ ñêîðîñòè)
+            // Используем центроид (можно кэшировать в LodLevel для скорости)
             Vector3f triDir = (finalLod.triangles[i].data[0] +
                 finalLod.triangles[i].data[1] +
                 finalLod.triangles[i].data[2]).normalized();
@@ -205,7 +205,7 @@ namespace ZL {
         std::vector<Triangle> output;
 
         for (const auto& t : input) {
-            // Âåðøèíû è èõ ID
+            // Вершины и их ID
             const Vector3f& a = t.data[0];
             const Vector3f& b = t.data[1];
             const Vector3f& c = t.data[2];
@@ -213,7 +213,7 @@ namespace ZL {
             const VertexID& id_b = t.ids[1];
             const VertexID& id_c = t.ids[2];
 
-            // 1. Âû÷èñëÿåì ñåðåäèíû (êîîðäèíàòû)
+            // 1. Вычисляем середины (координаты)
             Vector3f m_ab = ((a + b) * 0.5f).normalized();
             Vector3f m_bc = ((b + c) * 0.5f).normalized();
             Vector3f m_ac = ((a + c) * 0.5f).normalized();
@@ -226,12 +226,12 @@ namespace ZL {
             Vector3f pm_bc = m_bc;
             Vector3f pm_ac = m_ac;
 
-            // 2. Âû÷èñëÿåì ID íîâûõ âåðøèí
+            // 2. Вычисляем ID новых вершин
             VertexID id_mab = generateEdgeID(id_a, id_b);
             VertexID id_mbc = generateEdgeID(id_b, id_c);
             VertexID id_mac = generateEdgeID(id_a, id_c);
 
-            // 3. Ôîðìèðóåì 4 íîâûõ òðåóãîëüíèêà
+            // 3. Формируем 4 новых треугольника
             output.emplace_back(Triangle{ {a, pm_ab, pm_ac}, {id_a, id_mab, id_mac} }); // 0
             output.emplace_back(Triangle{ {pm_ab, b, pm_bc}, {id_mab, id_b, id_mbc} }); // 1
             output.emplace_back(Triangle{ {pm_ac, pm_bc, c}, {id_mac, id_mbc, id_c} }); // 2
@@ -282,31 +282,31 @@ namespace ZL {
             Vector2f(1.0f, 0.0f)
         };
 
-        const Vector3f colorPinkish = { 1.0f, 0.8f, 0.82f }; // Ñëåãêà ðîçîâàòûé
-        const Vector3f colorYellowish = { 1.0f, 1.0f, 0.75f }; // Ñëåãêà æåëòîâàòûé
+        const Vector3f colorPinkish = { 1.0f, 0.8f, 0.82f }; // Слегка розоватый
+        const Vector3f colorYellowish = { 1.0f, 1.0f, 0.75f }; // Слегка желтоватый
 
-        const float colorFrequency = 4.0f; // Ìàñøòàá ïÿòåí
+        const float colorFrequency = 4.0f; // Масштаб пятен
 
 
         for (const auto& t : lod.triangles) {
-            // --- Âû÷èñëÿåì ëîêàëüíûé áàçèñ òðåóãîëüíèêà (êàê â GetRotationForTriangle) ---
+            // --- Вычисляем локальный базис треугольника (как в GetRotationForTriangle) ---
             Vector3f vA = t.data[0];
             Vector3f vB = t.data[1];
             Vector3f vC = t.data[2];
 
-            Vector3f x_axis = (vC - vB).normalized(); // Íàïðàâëåíèå U
+            Vector3f x_axis = (vC - vB).normalized(); // Направление U
 
             Vector3f edge1 = vB - vA;
             Vector3f edge2 = vC - vA;
-            Vector3f z_axis = edge1.cross(edge2).normalized(); // Íîðìàëü ïëîñêîñòè
+            Vector3f z_axis = edge1.cross(edge2).normalized(); // Нормаль плоскости
 
-            // Ïðîâåðêà íàïðàâëåíèÿ íîðìàëè íàðóæó (îò öåíòðà ïëàíåòû)
+            // Проверка направления нормали наружу (от центра планеты)
             Vector3f centerToTri = (vA + vB + vC).normalized();
             if (z_axis.dot(centerToTri) < 0) {
                 z_axis = z_axis * -1.0f;
             }
 
-            Vector3f y_axis = z_axis.cross(x_axis).normalized(); // Íàïðàâëåíèå V
+            Vector3f y_axis = z_axis.cross(x_axis).normalized(); // Направление V
 
             for (int i = 0; i < 3; ++i) {
                 lod.vertexData.PositionData.push_back(t.data[i]);
@@ -315,7 +315,7 @@ namespace ZL {
                 lod.vertexData.TangentData.push_back(x_axis);
                 lod.vertexData.BinormalData.push_back(y_axis);
 
-                // Èñïîëüçóåì îäèí øóì äëÿ âûáîðà ìåæäó ðîçîâûì è æåëòûì
+                // Используем один шум для выбора между розовым и желтым
                 Vector3f dir = t.data[i].normalized();
                 float blendFactor = colorPerlin.noise(
                     dir(0) * colorFrequency,
@@ -323,10 +323,10 @@ namespace ZL {
                     dir(2) * colorFrequency
                 );
 
-                // Ïðèâîäèì øóì èç äèàïàçîíà [-1, 1] â [0, 1]
+                // Приводим шум из диапазона [-1, 1] в [0, 1]
                 blendFactor = blendFactor * 0.5f + 0.5f;
 
-                // Ëèíåéíàÿ èíòåðïîëÿöèÿ ìåæäó äâóìÿ öâåòàìè
+                // Линейная интерполяция между двумя цветами
                 Vector3f finalColor;
 
                 finalColor = colorPinkish + blendFactor * (colorYellowish - colorPinkish);
@@ -339,17 +339,17 @@ namespace ZL {
     LodLevel PlanetData::generateSphere(int subdivisions, float noiseCoeff) {
         const float t = (1.0f + std::sqrt(5.0f)) / 2.0f;
 
-        // 12 áàçîâûõ âåðøèí èêîñàýäðà
+        // 12 базовых вершин икосаэдра
         std::vector<Vector3f> icosaVertices = {
             {-1,  t,  0}, { 1,  t,  0}, {-1, -t,  0}, { 1, -t,  0},
             { 0, -1,  t}, { 0,  1,  t}, { 0, -1, -t}, { 0,  1, -t},
             { t,  0, -1}, { t,  0,  1}, {-t,  0, -1}, {-t,  0,  1}
         };
 
-        // Íîðìàëèçóåì âåðøèíû
+        // Нормализуем вершины
         for (auto& v : icosaVertices) v = v.normalized();
 
-        // 20 ãðàíåé èêîñàýäðà
+        // 20 граней икосаэдра
         struct IndexedTri { int v1, v2, v3; };
         std::vector<IndexedTri> faces = {
             {0, 11, 5}, {0, 5, 1}, {0, 1, 7}, {0, 7, 10}, {0, 10, 11},
@@ -365,7 +365,7 @@ namespace ZL {
             tri.data[1] = icosaVertices[f.v2];
             tri.data[2] = icosaVertices[f.v3];
 
-            // Ãåíåðèðóåì ID äëÿ áàçîâûõ âåðøèí (ìîæíî èñïîëüçîâàòü èõ êîîðäèíàòû)
+            // Генерируем ID для базовых вершин (можно использовать их координаты)
             for (int i = 0; i < 3; ++i) {
                 tri.ids[i] = std::to_string(tri.data[i](0)) + "_" +
                     std::to_string(tri.data[i](1)) + "_" +
@@ -374,15 +374,15 @@ namespace ZL {
             geometry.push_back(tri);
         }
 
-        // 3. Ðàçáèâàåì N ðàç
+        // 3. Разбиваем N раз
         for (int i = 0; i < subdivisions; i++) {
-            geometry = subdivideTriangles(geometry, 0.0f); // Øóì ïîêà èãíîðèðóåì
+            geometry = subdivideTriangles(geometry, 0.0f); // Шум пока игнорируем
         }
 
-        // 4. Ñîçäàåì LodLevel è çàïîëíÿåì òîïîëîãèþ (v2tMap)
+        // 4. Создаем LodLevel и заполняем топологию (v2tMap)
         LodLevel lodLevel = createLodLevel(geometry);
 
-        // Ïåðåñîáèðàåì v2tMap (îíà êðèòè÷íà äëÿ ðåëàêñàöèè)
+        // Пересобираем v2tMap (она критична для релаксации)
         lodLevel.v2tMap.clear();
         for (size_t i = 0; i < geometry.size(); ++i) {
             for (int j = 0; j < 3; ++j) {
@@ -390,12 +390,12 @@ namespace ZL {
             }
         }
 
-        // 5. Ïðèìåíÿåì èòåðàòèâíóþ ðåëàêñàöèþ (Lloyd-like)
-        // 5-10 èòåðàöèé äîñòàòî÷íî äëÿ îòëè÷íîé ñåòêè
+        // 5. Применяем итеративную релаксацию (Lloyd-like)
+        // 5-10 итераций достаточно для отличной сетки
         applySphericalRelaxation(lodLevel, 8);
 
-        // 6. Íàêëàäûâàåì øóì è îáíîâëÿåì àòðèáóòû
-        // ... (òâîé êîä íàëîæåíèÿ øóìà ÷åðåç Perlin)
+        // 6. Накладываем шум и обновляем атрибуты
+        // ... (твой код наложения шума через Perlin)
 
         recalculateMeshAttributes(lodLevel);
         return lodLevel;
@@ -410,7 +410,7 @@ namespace ZL {
             for (auto const& [vID, connectedTris] : lod.v2tMap) {
                 Vector3f centroid(0, 0, 0);
 
-                // Íàõîäèì ñðåäíþþ òî÷êó ñðåäè öåíòðîâ âñåõ ñîñåäíèõ òðåóãîëüíèêîâ
+                // Находим среднюю точку среди центров всех соседних треугольников
                 for (int triIdx : connectedTris) {
                     const auto& tri = lod.triangles[triIdx];
                     Vector3f faceCenter = (tri.data[0] + tri.data[1] + tri.data[2]) * (1.0f / 3.0f);
@@ -419,11 +419,11 @@ namespace ZL {
 
                 centroid = centroid * (1.0f / (float)connectedTris.size());
 
-                // Ïðîåöèðóåì îáðàòíî íà åäèíè÷íóþ ñôåðó
+                // Проецируем обратно на единичную сферу
                 newPositions[vID] = centroid.normalized();
             }
 
-            // Ñèíõðîíèçèðóåì äàííûå â òðåóãîëüíèêàõ
+            // Синхронизируем данные в треугольниках
             for (auto& tri : lod.triangles) {
                 for (int i = 0; i < 3; ++i) {
                     tri.data[i] = newPositions[tri.ids[i]];

src/planet/PlanetData.h

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include "utils/Perlin.h"
 #include "render/Renderer.h"
@@ -16,7 +16,7 @@ namespace ZL {
 
     struct Vector3fComparator {
         bool operator()(const Eigen::Vector3f& a, const Eigen::Vector3f& b) const {
-            // Ëåêñèêîãðàôè÷åñêîå ñðàâíåíèå (x, çàòåì y, çàòåì z)
+            // Лексикографическое сравнение (x, затем y, затем z)
             if (a.x() != b.x()) return a.x() < b.x();
             if (a.y() != b.y()) return a.y() < b.y();
             return a.z() < b.z();
@@ -87,11 +87,11 @@ namespace ZL {
         std::array<LodLevel, MAX_LOD_LEVELS> planetMeshLods;
         LodLevel planetAtmosphereLod;
 
-        int currentLod; // Ëîãè÷åñêèé òåêóùèé óðîâåíü äåòàëèçàöèè
+        int currentLod; // Логический текущий уровень детализации
 
         //std::map<Vector3f, VertexID, Vector3fComparator> initialVertexMap;
 
-        // Âíóòðåííèå ìåòîäû ãåíåðàöèè
+        // Внутренние методы генерации
         std::vector<Triangle> subdivideTriangles(const std::vector<Triangle>& inputTriangles, float noiseCoeff);
         LodLevel createLodLevel(const std::vector<Triangle>& triangles);
         void recalculateMeshAttributes(LodLevel& lod);
@@ -101,17 +101,17 @@ namespace ZL {
 
         void init();
 
-        // Ìåòîäû äîñòóïà ê äàííûì (äëÿ ðåíäåðåðà)
+        // Методы доступа к данным (для рендерера)
         const LodLevel& getLodLevel(int level) const;
         const LodLevel& getAtmosphereLod() const;
         int getCurrentLodIndex() const;
         int getMaxLodIndex() const;
 
-        // Ëîãèêà
+        // Логика
         std::pair<float, float> calculateZRange(float distanceToSurface);
         float distanceToPlanetSurfaceFast(const Vector3f& viewerPosition);
 
-        // Âîçâðàùàåò èíäåêñû òðåóãîëüíèêîâ, âèäèìûõ êàìåðîé
+        // Возвращает индексы треугольников, видимых камерой
         std::vector<int> getBestTriangleUnderCamera(const Vector3f& viewerPosition);
         std::vector<int> getTrianglesUnderCameraNew2(const Vector3f& viewerPosition);
 

src/planet/PlanetObject.cpp

@@ -101,15 +101,15 @@ namespace ZL {
 
 		// 1. Проверка порога движения (оптимизация из текущего кода)
 		float movementThreshold = 1.0f;
-		if ((Environment::shipPosition - lastUpdatePos).squaredNorm() < movementThreshold * movementThreshold
+		if ((Environment::shipState.position - lastUpdatePos).squaredNorm() < movementThreshold * movementThreshold
 			&& !triangleIndicesToDraw.empty()) {
 			//processMainThreadTasks(); // Все равно обрабатываем очередь OpenGL задач
 			return;
 		}
-		lastUpdatePos = Environment::shipPosition;
+		lastUpdatePos = Environment::shipState.position;
 
 		// 2. Получаем список видимых треугольников
-		auto newIndices = planetData.getTrianglesUnderCameraNew2(Environment::shipPosition);
+		auto newIndices = planetData.getTrianglesUnderCameraNew2(Environment::shipState.position);
 		std::sort(newIndices.begin(), newIndices.end());
 
 		// 3. Анализируем, что нужно загрузить
@@ -305,7 +305,7 @@ namespace ZL {
 		renderer.EnableVertexAttribArray(vTexCoordName);
 
 
-		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipPosition);
+		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
 		auto zRange = planetData.calculateZRange(dist);
 		const float currentZNear = zRange.first;
 		const float currentZFar = zRange.second;
@@ -320,7 +320,7 @@ namespace ZL {
 		renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
 		renderer.RotateMatrix(Environment::inverseShipMatrix);
 
-		renderer.TranslateMatrix(-Environment::shipPosition);
+		renderer.TranslateMatrix(-Environment::shipState.position);
 
 		const Matrix4f viewMatrix = renderer.GetCurrentModelViewMatrix();
 		
@@ -332,7 +332,7 @@ namespace ZL {
 		Matrix3f mr = GetRotationForTriangle(tr); // Та же матрица, что и при запекании
 
 		// Позиция камеры (корабля) в мире
-		renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
+		renderer.RenderUniform3fv("uViewPos", Environment::shipState.position.data());
 
 		//renderer.RenderUniform1f("uHeightScale", 0.08f);
 		renderer.RenderUniform1f("uHeightScale", 0.0f);
@@ -345,7 +345,7 @@ namespace ZL {
 		renderer.RenderUniform3fv("uLightDirWorld", sunDirWorld.data());
 
 		// Направление от центра планеты к игроку для расчета дня/ночи
-		Vector3f playerDirWorld = Environment::shipPosition.normalized();
+		Vector3f playerDirWorld = Environment::shipState.position.normalized();
 		renderer.RenderUniform3fv("uPlayerDirWorld", playerDirWorld.data());
 
 		// Тот же фактор освещенности игрока
@@ -394,7 +394,7 @@ namespace ZL {
 		renderer.EnableVertexAttribArray(vTexCoordName);
 
 
-		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipPosition);
+		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
 		auto zRange = planetData.calculateZRange(dist);
 		const float currentZNear = zRange.first;
 		const float currentZFar = zRange.second;
@@ -409,17 +409,17 @@ namespace ZL {
 		renderer.LoadIdentity();
 		renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
 		renderer.RotateMatrix(Environment::inverseShipMatrix);
-		renderer.TranslateMatrix(-Environment::shipPosition);
+		renderer.TranslateMatrix(-Environment::shipState.position);
 
 		renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
 		renderer.RenderUniform1f("uCurrentZFar", currentZFar);
-		renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
-		//std::cout << "uViewPos" << Environment::shipPosition << std::endl;
+		renderer.RenderUniform3fv("uViewPos", Environment::shipState.position.data());
+		//std::cout << "uViewPos" << Environment::shipState.position << std::endl;
 		// PlanetObject.cpp, метод drawStones
 		Vector3f sunDirWorld = Vector3f(1.0f, -1.0f, -1.0f).normalized();
 		renderer.RenderUniform3fv("uLightDirWorld", sunDirWorld.data());
 
-		Vector3f playerDirWorld = Environment::shipPosition.normalized();
+		Vector3f playerDirWorld = Environment::shipState.position.normalized();
 		float playerLightFactor = max(0.0f, (playerDirWorld.dot(-sunDirWorld) + 0.2f) / 1.2f);
 		renderer.RenderUniform1f("uPlayerLightFactor", playerLightFactor);
 		
@@ -479,7 +479,7 @@ namespace ZL {
 		renderer.EnableVertexAttribArray(vPositionName);
 		renderer.EnableVertexAttribArray(vNormalName);
 
-		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipPosition);
+		float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
 		auto zRange = planetData.calculateZRange(dist);
 		float currentZNear = zRange.first;
 		float currentZFar = zRange.second;
@@ -499,7 +499,7 @@ namespace ZL {
 		renderer.LoadIdentity();
 		renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
 		renderer.RotateMatrix(Environment::inverseShipMatrix);
-		renderer.TranslateMatrix(-Environment::shipPosition);
+		renderer.TranslateMatrix(-Environment::shipState.position);
 
 		const Matrix4f viewMatrix = renderer.GetCurrentModelViewMatrix();
 
@@ -536,7 +536,7 @@ namespace ZL {
 		renderer.RenderUniform3fv("uWorldLightDir", worldLightDir.data());
 
 		// 1. Рассчитываем uPlayerLightFactor (как в Game.cpp)
-		Vector3f playerDirWorld = Environment::shipPosition.normalized();
+		Vector3f playerDirWorld = Environment::shipState.position.normalized();
 		Vector3f sunDirWorld = Vector3f(1.0f, -1.0f, -1.0f).normalized();
 
 		// Насколько игрок на свету
@@ -549,7 +549,7 @@ namespace ZL {
 		// 3. Убедитесь, что uSkyColor тоже передан (в коде выше его не было)
 		renderer.RenderUniform3fv("uSkyColor", color.data());
 
-		//Vector3f playerDirWorld = Environment::shipPosition.normalized();
+		//Vector3f playerDirWorld = Environment::shipState.position.normalized();
 		renderer.RenderUniform3fv("uPlayerDirWorld", playerDirWorld.data());
 
 		glEnable(GL_BLEND);

src/planet/StoneObject.h

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #include "render/Renderer.h"
 #include "PlanetData.h"
 
@@ -6,11 +6,11 @@ namespace ZL {
 
     struct StoneParams
     {
-        static const float BASE_SCALE;          // Общий размер камня
-        static const float MIN_AXIS_SCALE;      // Минимальное растяжение/сжатие по оси
-        static const float MAX_AXIS_SCALE;      // Максимальное растяжение/сжатие по оси
-        static const float MIN_PERTURBATION;   // Минимальное радиальное возмущение вершины
-        static const float MAX_PERTURBATION;  // Максимальное радиальное возмущение вершины
+        static const float BASE_SCALE;          // Общий размер камня
+        static const float MIN_AXIS_SCALE;      // Минимальное растяжение/сжатие по оси
+        static const float MAX_AXIS_SCALE;      // Максимальное растяжение/сжатие по оси
+        static const float MIN_PERTURBATION;   // Минимальное радиальное возмущение вершины
+        static const float MAX_PERTURBATION;  // Максимальное радиальное возмущение вершины
         static const int STONES_PER_TRIANGLE;
 
     };
@@ -23,19 +23,19 @@ namespace ZL {
     };
 
     enum class ChunkStatus {
-        Empty,          // Данных нет
-        Generating,     // Задача в TaskManager (CPU)
-        ReadyToUpload,  // Данные в памяти, ждут очереди в главный поток
-        Live            // Загружено в GPU и готово к отрисовке
+        Empty,          // Данных нет
+        Generating,     // Задача в TaskManager (CPU)
+        ReadyToUpload,  // Данные в памяти, ждут очереди в главный поток
+        Live            // Загружено в GPU и готово к отрисовке
     };
 
     struct StoneGroup {
-        // mesh.PositionData и прочие будут заполняться в inflate()
+        // mesh.PositionData и прочие будут заполняться в inflate()
         VertexDataStruct mesh;
 
         std::vector<std::vector<StoneInstance>> allInstances;
 
-        // Очищает старую геометрию и генерирует новую для указанных индексов
+        // Очищает старую геометрию и генерирует новую для указанных индексов
         std::vector<VertexRenderStruct> inflate(int count);
 
         VertexRenderStruct inflateOne(int index, float scaleModifier);
@@ -43,13 +43,13 @@ namespace ZL {
 
         std::vector<ChunkStatus> statuses;
 
-        // Инициализация статусов при создании группы
+        // Инициализация статусов при создании группы
         void initStatuses() {
             statuses.assign(allInstances.size(), ChunkStatus::Empty);
         }
     };
 
-    // Теперь возвращает заготовку со всеми параметрами, но без тяжелого меша
+    // Теперь возвращает заготовку со всеми параметрами, но без тяжелого меша
     StoneGroup CreateStoneGroupData(uint64_t globalSeed, const LodLevel& lodLevel);
 
     Triangle createLocalTriangle(const Triangle& sampleTri);