salmon-engine-projects/space-game001
14
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring

Browse Source
This commit is contained in:
Vladislav Khorev 2026-04-16 18:07:22 +03:00
parent 2ef2e456f7
commit f2f56125f0
14 changed files with 9 additions and 4265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
proj-windows/CMakeLists.txt
View File

@ -36,41 +36,24 @@ add_executable(space-game001
../src/utils/Utils.h ../src/utils/Utils.h
../src/SparkEmitter.cpp ../src/SparkEmitter.cpp
../src/SparkEmitter.h ../src/SparkEmitter.h
# ../src/planet/PlanetObject.cpp
# ../src/planet/PlanetObject.h
# ../src/planet/PlanetData.cpp
# ../src/planet/PlanetData.h
../src/utils/Perlin.cpp ../src/utils/Perlin.cpp
../src/utils/Perlin.h ../src/utils/Perlin.h
../src/utils/TaskManager.cpp ../src/utils/TaskManager.cpp
../src/utils/TaskManager.h ../src/utils/TaskManager.h
# ../src/planet/StoneObject.cpp
# ../src/planet/StoneObject.h
../src/render/FrameBuffer.cpp ../src/render/FrameBuffer.cpp
../src/render/FrameBuffer.h ../src/render/FrameBuffer.h
../src/render/ShadowMap.cpp ../src/render/ShadowMap.cpp
../src/render/ShadowMap.h ../src/render/ShadowMap.h
../src/UiManager.cpp ../src/UiManager.cpp
../src/UiManager.h ../src/UiManager.h
../src/Projectile.h # ../src/Projectile.h
../src/Projectile.cpp # ../src/Projectile.cpp
# ../src/network/NetworkInterface.h
# ../src/network/LocalClient.h
# ../src/network/LocalClient.cpp
# ../src/network/ClientState.h
# ../src/network/ClientState.cpp
# ../src/network/WebSocketClient.h
# ../src/network/WebSocketClient.cpp
# ../src/network/WebSocketClientBase.h
# ../src/network/WebSocketClientBase.cpp
# ../src/network/WebSocketClientEmscripten.h
# ../src/network/WebSocketClientEmscripten.cpp
../src/render/TextRenderer.h ../src/render/TextRenderer.h
../src/render/TextRenderer.cpp ../src/render/TextRenderer.cpp
../src/MenuManager.h ../src/MenuManager.h
../src/MenuManager.cpp ../src/MenuManager.cpp
# ../src/Space.h ../src/Location.h
# ../src/Space.cpp ../src/Location.cpp
../src/GameConstants.h ../src/GameConstants.h
../src/GameConstants.cpp ../src/GameConstants.cpp
../src/ScriptEngine.h ../src/ScriptEngine.h
@ -115,8 +98,6 @@ target_compile_definitions(space-game001 PRIVATE
SDL_MAIN_HANDLED SDL_MAIN_HANDLED
# DEBUG_LIGHT # DEBUG_LIGHT
# SHOW_PATH # SHOW_PATH
# NETWORK
# SIMPLIFIED
) )
# Линкуем с SDL2main, если он вообще установлен # Линкуем с SDL2main, если он вообще установлен

4
src/Character.h
View File

@ -70,8 +70,8 @@ public:
bool canAttack = false; bool canAttack = false;
Character* attackTarget = nullptr; Character* attackTarget = nullptr;
bool isPlayer = false; bool isPlayer = false;
//bool useGpuSkinning = true; bool useGpuSkinning = true;
bool useGpuSkinning = false; //bool useGpuSkinning = false;
float interactionRadius = 0.0f; float interactionRadius = 0.0f;

1
src/Game.cpp
View File

@ -1,7 +1,6 @@
#include "Game.h" #include "Game.h"
#include "AnimatedModel.h" #include "AnimatedModel.h"
#include "BoneAnimatedModel.h" #include "BoneAnimatedModel.h"
#include "planet/PlanetData.h"
#include "utils/Utils.h" #include "utils/Utils.h"
#include "render/OpenGlExtensions.h" #include "render/OpenGlExtensions.h"
#include <iostream> #include <iostream>

2
src/Game.h
View File

@ -5,9 +5,7 @@
#include "Environment.h" #include "Environment.h"
#include "render/TextureManager.h" #include "render/TextureManager.h"
#include "SparkEmitter.h" #include "SparkEmitter.h"
#include "planet/PlanetObject.h"
#include "UiManager.h" #include "UiManager.h"
#include "Projectile.h"
#include "utils/TaskManager.h" #include "utils/TaskManager.h"
#include "items/GameObjectLoader.h" #include "items/GameObjectLoader.h"
#include "items/Item.h" #include "items/Item.h"

2
src/Location.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "Location.h"

1
src/Location.h Normal file
View File

@ -0,0 +1 @@
#pragma once

2353
src/Space.cpp
View File

File diff suppressed because it is too large Load Diff

204
src/Space.h
View File

@ -1,204 +0,0 @@
#pragma once
#include "render/Renderer.h"
#include "Environment.h"
#include "render/TextureManager.h"
#include "SparkEmitter.h"
#include "planet/PlanetObject.h"
#include "UiManager.h"
#include "Projectile.h"
#include "utils/TaskManager.h"
#include "network/NetworkInterface.h"
#include <queue>
#include <vector>
#include <string>
#include <memory>
#include <render/TextRenderer.h>
#include "MenuManager.h"
#include <unordered_set>
namespace ZL {
struct BoxCoords
{
Vector3f pos;
Matrix3f m;
};
class Space {
public:
Space(Renderer& iRenderer, TaskManager& iTaskManager, MainThreadHandler& iMainThreadHandler, std::unique_ptr<INetworkClient>& iNetworkClient, MenuManager& iMenuManager);
~Space();
void setup();
void update();
Renderer& renderer;
TaskManager& taskManager;
MainThreadHandler& mainThreadHandler;
std::unique_ptr<INetworkClient>& networkClient;
MenuManager& menuManager;
public:
void processTickCount(int64_t newTickCount, int64_t delta);
void drawScene();
void drawCubemap(float skyPercent);
void drawShip();
void drawBoxes();
void drawBoxesLabels();
void drawRemoteShips();
void drawRemoteShipsLabels();
void fireProjectiles();
void handleDown(int mx, int my);
void handleUp(int mx, int my);
void handleMotion(int mx, int my);
std::vector<BoxCoords> boxCoordsArr;
std::vector<VertexRenderStruct> boxRenderArr;
std::vector<std::string> boxLabels;
std::unique_ptr<TextRenderer> textRenderer;
std::unordered_map<int, ClientState> remotePlayerStates;
std::unordered_map<int, SparkEmitter> remoteShipSparkEmitters;
float newShipVelocity = 0;
static const size_t CONST_TIMER_INTERVAL = 10;
static const size_t CONST_MAX_TIME_INTERVAL = 1000;
std::shared_ptr<Texture> sparkTexture;
std::shared_ptr<Texture> spaceshipTexture;
std::shared_ptr<Texture> cubemapTexture;
VertexDataStruct spaceshipBase;
VertexRenderStruct spaceship;
std::shared_ptr<Texture> cargoTexture;
VertexDataStruct cargoBase;
VertexRenderStruct cargo;
VertexRenderStruct cubemap;
std::shared_ptr<Texture> boxTexture;
VertexDataStruct boxBase;
SparkEmitter sparkEmitter;
SparkEmitter sparkEmitterCargo;
SparkEmitter projectileEmitter;
SparkEmitter explosionEmitter;
PlanetObject planetObject;
std::vector<std::unique_ptr<Projectile>> projectiles;
std::shared_ptr<Texture> projectileTexture;
float projectileCooldownMs = 500.0f;
int64_t lastProjectileFireTime = 0;
int maxProjectiles = 500;
//std::vector<Vector3f> shipLocalEmissionPoints;
bool shipAlive = true;
bool gameOver = false;
bool firePressed = false;
std::vector<bool> boxAlive;
float shipCollisionRadius = 15.0f;
float boxCollisionRadius = 2.0f;
bool showExplosion = false;
uint64_t lastExplosionTime = 0;
const uint64_t explosionDurationMs = 500;
bool serverBoxesApplied = false;
bool nearPickupBox = false;
static constexpr float MAX_DIST_SQ = 10000.f * 10000.f;
static constexpr float FADE_START = 6000.f;
static constexpr float FADE_RANGE = 4000.f;
static constexpr float BASE_SCALE = 140.f;
static constexpr float PERSPECTIVE_K = 0.05f; // Tune
static constexpr float MIN_SCALE = 0.4f;
static constexpr float MAX_SCALE = 0.8f;
static constexpr float CLOSE_DIST = 600.0f;
std::unordered_set<int> deadRemotePlayers;
int playerScore = 0;
int prevPlayerScore = 0;
bool wasConnectedToServer = false;
bool playerListVisible = false;
int manualTrackedTargetId = -1;
static constexpr float TARGET_MAX_DIST = 50000.0f;
static constexpr float TARGET_MAX_DIST_SQ = TARGET_MAX_DIST * TARGET_MAX_DIST;
// --- Target HUD (brackets + offscreen arrow) ---
int trackedTargetId = -1;
bool targetWasVisible = false;
float targetAcquireAnim = 0.0f; // 0..1 схлопывание (0 = далеко, 1 = на месте)
// временный меш для HUD (будем перезаливать VBO маленькими порциями)
VertexRenderStruct hudTempMesh;
// helpers
void drawTargetHud(); // рисует рамку или стрелку
int pickTargetId() const; // ???????? ???? (????: ????????? ????? ????????? ?????)
void resetPlayerState();
void clearTextRendererCache();
void updateShowPlayersButtonState();
bool showPlayersButtonEnabled = false;
// Player list overlay
void buildAndShowPlayerList();
void closePlayerList();
void rebuildPlayerListIfVisible();
void clearPlayerListIfVisible();
std::shared_ptr<UiNode> buildPlayerListRoot();
void updateSparkEmitters(float deltaMs);
void prepareSparkEmittersForDraw();
void drawShipSparkEmitters();
// Crosshair HUD
struct CrosshairConfig {
bool enabled = true;
int refW = 1280;
int refH = 720;
float scaleMul = 1.0f;
Eigen::Vector3f color = { 1.f, 1.f, 1.f };
float alpha = 1.0f; // cl_crosshairalpha
float thicknessPx = 2.0f; // cl_crosshairthickness
float gapPx = 10.0f;
float topLenPx = 14.0f;
float topAngleDeg = 90.0f;
struct Arm { float lenPx; float angleDeg; };
std::vector<Arm> arms;
};
CrosshairConfig crosshairCfg;
bool crosshairCfgLoaded = false;
// кеш геометрии
VertexRenderStruct crosshairMesh;
bool crosshairMeshValid = false;
int crosshairLastW = 0, crosshairLastH = 0;
float crosshairLastAlpha = -1.0f;
float crosshairLastThickness = -1.0f;
float crosshairLastGap = -1.0f;
float crosshairLastScaleMul = -1.0f;
bool loadCrosshairConfig(const std::string& path);
void rebuildCrosshairMeshIfNeeded();
void drawCrosshair();
};
} // namespace ZL

455
src/planet/PlanetData.cpp
View File

@ -1,455 +0,0 @@
#include "PlanetData.h"
#include <iostream>
#include <numeric>
#include <cmath>
#include <algorithm>
namespace ZL {
Matrix3f GetRotationForTriangle(const Triangle& tri);
const float PlanetData::PLANET_RADIUS = 20000.f;
const Vector3f PlanetData::PLANET_CENTER_OFFSET = Vector3f{ 0.f, 0.f, 0.0f };
// --- Константы диапазонов (перенесены из 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);
Vector3f N = AB.cross(AC).normalized();
Vector3f AP = P + A * (-1.0f);
float distance = N.dot(AP);
return P + N * (-distance);
}
PlanetData::PlanetData()
: perlin(77777)
, colorPerlin(123123)
//, currentLod(0)
{
// currentLod = planetMeshLods.size() - 1; // Start with max LOD
/*
initialVertexMap = {
{{ 0.0f, 1.0f, 0.0f}, "A"},
{{ 0.0f, -1.0f, 0.0f}, "B"},
{{ 1.0f, 0.0f, 0.0f}, "C"},
{{-1.0f, 0.0f, 0.0f}, "D"},
{{ 0.0f, 0.0f, 1.0f}, "E"},
{{ 0.0f, 0.0f, -1.0f}, "F"}
};*/
}
void PlanetData::init() {
for (int i = 0; i < planetMeshLods.size(); i++) {
//planetMeshLods[i] = generateSphere(i, 0.01f);
planetMeshLods[i] = generateSphere(i, 0.f);
planetMeshLods[i].Scale(PLANET_RADIUS);
planetMeshLods[i].Move(PLANET_CENTER_OFFSET);
}
planetAtmosphereLod = generateSphere(5, 0);
planetAtmosphereLod.Scale(PLANET_RADIUS * 1.03);
planetAtmosphereLod.Move(PLANET_CENTER_OFFSET);
const auto& lodLevel = getLodLevel();
for (size_t i = 0; i < lodLevel.triangles.size(); i++)
{
if (i % 100 == 0)
{
PlanetCampObject campObject;
campObject.position = (lodLevel.triangles[i].data[0] +
lodLevel.triangles[i].data[1] +
lodLevel.triangles[i].data[2]) / 3.0f;
auto newM = Eigen::Quaternionf(Eigen::AngleAxisf(M_PI * 0.5, Eigen::Vector3f::UnitX())).toRotationMatrix();
campObject.rotation = GetRotationForTriangle(lodLevel.triangles[i]).inverse() * newM;
campObjects.push_back(campObject);
}
}
}
const LodLevel& PlanetData::getLodLevel() const {
return planetMeshLods.at(MAX_LOD_LEVELS-1);
}
const LodLevel& PlanetData::getAtmosphereLod() const {
return planetAtmosphereLod;
}
/*
int PlanetData::getCurrentLodIndex() const {
return currentLod;
}
int PlanetData::getMaxLodIndex() const {
return static_cast<int>(planetMeshLods.size() - 1);
}*/
std::pair<float, float> PlanetData::calculateZRange(float dToPlanetSurface) {
float currentZNear;
float currentZFar;
float alpha;
if (dToPlanetSurface > 2000)
{
currentZNear = 1000;
currentZFar = currentZNear * 100;
}
else if (dToPlanetSurface > 1200)
{
currentZNear = 500;
currentZFar = currentZNear * 100;
}
else if (dToPlanetSurface > 650)
{
currentZNear = 250;
currentZFar = currentZNear * 100;
}
else if (dToPlanetSurface > 160)
{
currentZNear = 125;
currentZFar = currentZNear * 150;
}
else if (dToPlanetSurface > 100)
{
currentZNear = 65;
currentZFar = currentZNear * 170;
}
else if (dToPlanetSurface > 40)
{
currentZNear = 32;
currentZFar = 10000.f;
}
else if (dToPlanetSurface > 20)
{
currentZNear = 16;
currentZFar = 5000.f;
}
else if (dToPlanetSurface > 5)
{
currentZNear = 8;
currentZFar = 2500.f;
}
else
{
currentZNear = 4;
currentZFar = 1250.f;
}
return { currentZNear, currentZFar };
}
float PlanetData::distanceToPlanetSurfaceFast(const Vector3f& viewerPosition)
{
Vector3f shipLocalPosition = viewerPosition - PLANET_CENTER_OFFSET;
return sqrt(shipLocalPosition.squaredNorm()) - PLANET_RADIUS;
}
std::vector<int> PlanetData::getBestTriangleUnderCamera(const Vector3f& viewerPosition) {
const LodLevel& finalLod = planetMeshLods[MAX_LOD_LEVELS - 1]; // Работаем с текущим активным LOD
Vector3f targetDir = (viewerPosition - PLANET_CENTER_OFFSET).normalized();
int bestTriangle = -1;
float maxDot = -1.0f;
// Шаг 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();
float dot = targetDir.dot(triDir);
if (dot > maxDot) {
maxDot = dot;
bestTriangle = i;
}
}
if (bestTriangle == -1) return {};
return { bestTriangle };
}
std::vector<int> PlanetData::getTrianglesUnderCameraNew2(const Vector3f& viewerPosition) {
const LodLevel& finalLod = planetMeshLods[MAX_LOD_LEVELS - 1];
Vector3f shipLocal = viewerPosition - PLANET_CENTER_OFFSET;
float currentDist = shipLocal.norm();
Vector3f targetDir = shipLocal.normalized();
// Желаемый радиус покрытия на поверхности планеты (в метрах/единицах движка)
// Подбери это значение так, чтобы камни вокруг корабля всегда были видны.
const float desiredCoverageRadius = 3000.0f;
// Вычисляем порог косинуса на основе желаемого радиуса и текущего расстояния.
// Чем мы дальше (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 для скорости)
Vector3f triDir = (finalLod.triangles[i].data[0] +
finalLod.triangles[i].data[1] +
finalLod.triangles[i].data[2]).normalized();
if (targetDir.dot(triDir) > searchThreshold) {
result.push_back(i);
}
}
if (result.empty()) return getBestTriangleUnderCamera(viewerPosition);
return result;
}
std::vector<Triangle> PlanetData::subdivideTriangles(const std::vector<Triangle>& input, float noiseCoeff) {
std::vector<Triangle> output;
for (const auto& t : input) {
// Вершины и их ID
const Vector3f& a = t.data[0];
const Vector3f& b = t.data[1];
const Vector3f& c = t.data[2];
const VertexID& id_a = t.ids[0];
const VertexID& id_b = t.ids[1];
const VertexID& id_c = t.ids[2];
// 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();
//Vector3f pm_ab = m_ab * perlin.getSurfaceHeight(m_ab, noiseCoeff);
//Vector3f pm_bc = m_bc * perlin.getSurfaceHeight(m_bc, noiseCoeff);
//Vector3f pm_ac = m_ac * perlin.getSurfaceHeight(m_ac, noiseCoeff);
Vector3f pm_ab = m_ab;
Vector3f pm_bc = m_bc;
Vector3f pm_ac = m_ac;
// 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 новых треугольника
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
output.emplace_back(Triangle{ {pm_ab, pm_bc, pm_ac}, {id_mab, id_mbc, id_mac} }); // 3
}
return output;
}
LodLevel PlanetData::createLodLevel(const std::vector<Triangle>& geometry) {
LodLevel result;
result.triangles = geometry;
size_t vertexCount = geometry.size() * 3;
result.VertexIDs.reserve(vertexCount);
for (const auto& t : geometry) {
for (int i = 0; i < 3; ++i) {
result.VertexIDs.push_back(t.ids[i]);
}
}
return result;
}
void PlanetData::recalculateMeshAttributes(LodLevel& lod)
{
size_t vertexCount = lod.triangles.size() * 3;
lod.vertexData.PositionData.clear();
lod.vertexData.NormalData.clear();
lod.vertexData.TexCoordData.clear();
lod.vertexData.TangentData.clear();
lod.vertexData.BinormalData.clear();
lod.vertexData.ColorData.clear();
lod.vertexData.PositionData.reserve(vertexCount);
lod.vertexData.NormalData.reserve(vertexCount);
lod.vertexData.TexCoordData.reserve(vertexCount);
lod.vertexData.TangentData.reserve(vertexCount);
lod.vertexData.BinormalData.reserve(vertexCount);
lod.vertexData.ColorData.reserve(vertexCount);
const std::array<Vector2f, 3> triangleUVs = {
Vector2f(0.5f, 1.0f),
Vector2f(0.0f, 0.0f),
Vector2f(1.0f, 0.0f)
};
const Vector3f colorPinkish = { 1.0f, 0.8f, 0.82f }; // Слегка розоватый
const Vector3f colorYellowish = { 1.0f, 1.0f, 0.75f }; // Слегка желтоватый
const float colorFrequency = 4.0f; // Масштаб пятен
for (const auto& t : lod.triangles) {
// --- Вычисляем локальный базис треугольника (как в GetRotationForTriangle) ---
Vector3f vA = t.data[0];
Vector3f vB = t.data[1];
Vector3f vC = t.data[2];
Vector3f x_axis = (vC - vB).normalized(); // Направление U
Vector3f edge1 = vB - vA;
Vector3f edge2 = vC - vA;
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
for (int i = 0; i < 3; ++i) {
lod.vertexData.PositionData.push_back(t.data[i]);
lod.vertexData.NormalData.push_back(z_axis);
lod.vertexData.TexCoordData.push_back(triangleUVs[i]);
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,
dir(1) * colorFrequency,
dir(2) * colorFrequency
);
// Приводим шум из диапазона [-1, 1] в [0, 1]
blendFactor = blendFactor * 0.5f + 0.5f;
// Линейная интерполяция между двумя цветами
Vector3f finalColor;
finalColor = colorPinkish + blendFactor * (colorYellowish - colorPinkish);
lod.vertexData.ColorData.push_back(finalColor);
}
}
}
LodLevel PlanetData::generateSphere(int subdivisions, float noiseCoeff) {
const float t = (1.0f + std::sqrt(5.0f)) / 2.0f;
// 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 граней икосаэдра
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},
{1, 5, 9}, {5, 11, 4}, {11, 10, 2}, {10, 7, 6}, {7, 1, 8},
{3, 9, 4}, {3, 4, 2}, {3, 2, 6}, {3, 6, 8}, {3, 8, 9},
{4, 9, 5}, {2, 4, 11}, {6, 2, 10}, {8, 6, 7}, {9, 8, 1}
};
std::vector<Triangle> geometry;
for (auto& f : faces) {
Triangle tri;
tri.data[0] = icosaVertices[f.v1];
tri.data[1] = icosaVertices[f.v2];
tri.data[2] = icosaVertices[f.v3];
// Генерируем 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)) + "_" +
std::to_string(tri.data[i](2));
}
geometry.push_back(tri);
}
// 3. Разбиваем N раз
for (int i = 0; i < subdivisions; i++) {
geometry = subdivideTriangles(geometry, 0.0f); // Шум пока игнорируем
}
// 4. Создаем LodLevel и заполняем топологию (v2tMap)
LodLevel lodLevel = createLodLevel(geometry);
// Пересобираем v2tMap (она критична для релаксации)
lodLevel.v2tMap.clear();
for (size_t i = 0; i < geometry.size(); ++i) {
for (int j = 0; j < 3; ++j) {
lodLevel.v2tMap[geometry[i].ids[j]].push_back((int)i);
}
}
// 5. Применяем итеративную релаксацию (Lloyd-like)
// 5-10 итераций достаточно для отличной сетки
applySphericalRelaxation(lodLevel, 8);
// 6. Накладываем шум и обновляем атрибуты
// ... (твой код наложения шума через Perlin)
recalculateMeshAttributes(lodLevel);
return lodLevel;
}
void PlanetData::applySphericalRelaxation(LodLevel& lod, int iterations) {
for (int iter = 0; iter < iterations; ++iter) {
std::map<VertexID, Vector3f> newPositions;
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);
centroid = centroid + faceCenter;
}
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]];
}
}
}
}
}

134
src/planet/PlanetData.h
View File

@ -1,134 +0,0 @@
#pragma once
#include "utils/Perlin.h"
#include "render/Renderer.h"
#include <vector>
#include <array>
#include <string>
#include <map>
#include <set>
namespace ZL {
using VertexID = std::string;
using V2TMap = std::map<VertexID, std::vector<int>>;
struct Vector3fComparator {
bool operator()(const Eigen::Vector3f& a, const Eigen::Vector3f& b) const {
// Лексикографическое сравнение (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();
}
};
VertexID generateEdgeID(const VertexID& id1, const VertexID& id2);
constexpr static int MAX_LOD_LEVELS = 6;
struct Triangle
{
std::array<Vector3f, 3> data;
std::array<VertexID, 3> ids;
Triangle()
{
}
Triangle(Vector3f p1, Vector3f p2, Vector3f p3)
: data{ p1, p2, p3 }
{
}
Triangle(std::array<Vector3f, 3> idata, std::array<VertexID, 3> iids)
: data{ idata }
, ids{ iids }
{
}
};
struct LodLevel
{
std::vector<Triangle> triangles;
VertexDataStruct vertexData;
std::vector<VertexID> VertexIDs;
V2TMap v2tMap;
void Scale(float s)
{
vertexData.Scale(s);
for (auto& t : triangles) {
for (int i = 0; i < 3; i++) {
t.data[i] = t.data[i] * s;
}
}
}
void Move(Vector3f pos)
{
vertexData.Move(pos);
for (auto& t : triangles) {
for (int i = 0; i < 3; i++) {
t.data[i] = t.data[i] + pos;
}
}
}
};
struct PlanetCampObject
{
Vector3f position;
Matrix3f rotation;
std::array<Vector3f, 5> platformPos = {
Vector3f{ 0.f, 0.f,-38.f },
Vector3f{ 20.f, 0.f,-18.f },
Vector3f{ 20.f, 0.f,-58.f },
Vector3f{ -20.f, 0.f,-58.f },
Vector3f{ -20.f, 0.f,-18.f }
};
};
class PlanetData {
public:
static const float PLANET_RADIUS;
static const Vector3f PLANET_CENTER_OFFSET;
private:
PerlinNoise perlin;
PerlinNoise colorPerlin;
std::array<LodLevel, MAX_LOD_LEVELS> planetMeshLods;
LodLevel planetAtmosphereLod;
//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);
LodLevel generateSphere(int subdivisions, float noiseCoeff);
public:
PlanetData();
void init();
const LodLevel& getLodLevel() const;
const LodLevel& getAtmosphereLod() 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);
void applySphericalRelaxation(LodLevel& lod, int iterations);
std::vector<PlanetCampObject> campObjects;
};
} // namespace ZL

611
src/planet/PlanetObject.cpp
View File

@ -1,611 +0,0 @@
#include "PlanetObject.h"
#include <random>
#include <cmath>
#include "render/OpenGlExtensions.h"
#include "Environment.h"
#include "StoneObject.h"
#include "utils/TaskManager.h"
#include "TextModel.h"
#include "GameConstants.h"
namespace ZL {
extern float x;
#if defined EMSCRIPTEN || defined __ANDROID__
using std::min;
using std::max;
#endif
extern const char* CONST_ZIP_FILE;
Matrix3f GetRotationForTriangle(const Triangle& tri) {
Vector3f vA = tri.data[0];
Vector3f vB = tri.data[1];
Vector3f vC = tri.data[2];
// 1. Вычисляем ось X (горизонталь).
Vector3f x_axis = (vC - vB).normalized();
// 2. Вычисляем нормаль (ось Z).
// Порядок cross product (AB x AC) определит "лицевую" сторону.
Vector3f edge1 = vB - vA;
Vector3f edge2 = vC - vA;
Vector3f z_axis = edge1.cross(edge2).normalized();
// 3. Вычисляем ось Y (вертикаль).
// В ортонормированном базисе Y всегда перпендикулярна Z и X.
Vector3f y_axis = z_axis.cross(x_axis).normalized();
// 4. Формируем прямую матрицу поворота (Rotation/World Matrix).
Matrix3f rot;
// Столбец 0: Ось X
rot.data()[0] = x_axis.data()[0];
rot.data()[3] = x_axis.data()[1];
rot.data()[6] = x_axis.data()[2];
// Столбец 1: Ось Y
rot.data()[1] = y_axis.data()[0];
rot.data()[4] = y_axis.data()[1];
rot.data()[7] = y_axis.data()[2];
// Столбец 2: Ось Z
rot.data()[2] = z_axis.data()[0];
rot.data()[5] = z_axis.data()[1];
rot.data()[8] = z_axis.data()[2];
return rot;
}
PlanetObject::PlanetObject(Renderer& iRenderer, TaskManager& iTaskManager, MainThreadHandler& iMainThreadHandler)
: renderer(iRenderer),
taskManager(iTaskManager),
mainThreadHandler(iMainThreadHandler)
{
}
void PlanetObject::init() {
// 1. Инициализируем данные (генерация мешей)
planetData.init();
// 2. Забираем данные для VBO
// Берем максимальный LOD для начальной отрисовки
planetRenderStruct.data = planetData.getLodLevel().vertexData;
//planetRenderStruct.data.PositionData.resize(9);
planetRenderStruct.RefreshVBO();
sandTexture = std::make_unique<Texture>(CreateTextureDataFromPng("resources/sand2.png", CONST_ZIP_FILE));
stoneTexture = std::make_unique<Texture>(CreateTextureDataFromPng("resources/rockdark3.png", CONST_ZIP_FILE));
// Атмосфера
planetAtmosphereRenderStruct.data = planetData.getAtmosphereLod().vertexData;
if (planetAtmosphereRenderStruct.data.PositionData.size() > 0)
{
planetAtmosphereRenderStruct.RefreshVBO();
}
planetStones = CreateStoneGroupData(778, planetData.getLodLevel());
//stonesToRender = planetStones.inflate(planetStones.allInstances.size());
stonesToRender.resize(planetStones.allInstances.size());
planetStones.initStatuses();
stoneToBake = planetStones.inflateOne(0, 0.75);
/*
campPlatform.data = LoadFromTextFile02("resources/platform1.txt", CONST_ZIP_FILE);
campPlatform.RefreshVBO();
campPlatformTexture = std::make_unique<Texture>(CreateTextureDataFromPng("resources/platform_base.png", CONST_ZIP_FILE));
*/
}
void PlanetObject::update(float deltaTimeMs) {
// 1. Проверка порога движения (оптимизация из текущего кода)
float movementThreshold = 1.0f;
if ((Environment::shipState.position - lastUpdatePos).squaredNorm() < movementThreshold * movementThreshold
&& !triangleIndicesToDraw.empty()) {
//processMainThreadTasks(); // Все равно обрабатываем очередь OpenGL задач
return;
}
lastUpdatePos = Environment::shipState.position;
// 2. Получаем список видимых треугольников
auto newIndices = planetData.getTrianglesUnderCameraNew2(Environment::shipState.position);
std::sort(newIndices.begin(), newIndices.end());
// 3. Анализируем, что нужно загрузить
for (int triIdx : newIndices) {
if (planetStones.statuses[triIdx] == ChunkStatus::Empty) {
// Помечаем, чтобы не спамить задачами
planetStones.statuses[triIdx] = ChunkStatus::Generating;
// Отправляем тяжелую математику в TaskManager
taskManager.EnqueueBackgroundTask([this, triIdx]() {
// Выполняется в фоновом потоке: только генерация геометрии в RAM
float scaleModifier = 1.0f;
VertexDataStruct generatedData = planetStones.inflateOneDataOnly(triIdx, scaleModifier);
// Передаем задачу на загрузку в GPU в очередь главного потока
this->mainThreadHandler.EnqueueMainThreadTask([this, triIdx, data = std::move(generatedData)]() mutable {
// Проверяем актуальность: если треугольник всё еще в списке видимых
auto it = std::find(triangleIndicesToDraw.begin(), triangleIndicesToDraw.end(), triIdx);
if (it != triangleIndicesToDraw.end()) {
stonesToRender[triIdx].data = std::move(data);
stonesToRender[triIdx].RefreshVBO(); // OpenGL вызов
planetStones.statuses[triIdx] = ChunkStatus::Live;
}
else {
// Если уже не нужен — просто сбрасываем статус
planetStones.statuses[triIdx] = ChunkStatus::Empty;
}
});
});
}
}
// 4. Очистка (Unload)
// Если статус Live, но треугольника нет в новых индексах — освобождаем GPU память
for (size_t i = 0; i < planetStones.statuses.size(); ++i) {
if (planetStones.statuses[i] == ChunkStatus::Live) {
bool isVisible = std::binary_search(newIndices.begin(), newIndices.end(), (int)i);
if (!isVisible) {
// Очищаем данные и VBO (деструкторы shared_ptr в VertexRenderStruct сделают glDeleteBuffers)
stonesToRender[i].data.PositionData.clear();
stonesToRender[i].vao.reset();
stonesToRender[i].positionVBO.reset();
stonesToRender[i].normalVBO.reset();
stonesToRender[i].tangentVBO.reset();
stonesToRender[i].binormalVBO.reset();
stonesToRender[i].colorVBO.reset();
stonesToRender[i].texCoordVBO.reset();
planetStones.statuses[i] = ChunkStatus::Empty;
}
}
}
triangleIndicesToDraw = std::move(newIndices);
// 5. Выполняем одну задачу из очереди OpenGL (RefreshVBO и т.д.)
//processMainThreadTasks();
}
void PlanetObject::bakeStoneTexture(Renderer& renderer) {
glViewport(0, 0, 512, 512);
glClearColor(0,0,0, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
static const std::string planetBakeShaderName = "planetBake";
renderer.shaderManager.PushShader(planetBakeShaderName);
renderer.RenderUniform1i(textureUniformName, 0);
Triangle tr = planetData.getLodLevel().triangles[0];
// 1. Получаем матрицу вращения (оси в столбцах)
Matrix3f mr = GetRotationForTriangle(tr);
// 2. Трансформируем вершины в локальное пространство экрана, чтобы найти габариты
// Используем MultMatrixVector(Matrix, Vector).
// Если ваша функция считает V * M, то передайте Inverse(mr).
Vector3f rA = mr * tr.data[0];
Vector3f rB = mr * tr.data[1];
Vector3f rC = mr * tr.data[2];
// 3. Вычисляем реальные границы треугольника после поворота
float minX = min(rA(0), min(rB(0), rC(0)));
float maxX = max(rA(0), max(rB(0), rC(0)));
float minY = min(rA(1), min(rB(1), rC(1)));
float maxY = max(rA(1), max(rB(1), rC(1)));
// Находим центр и размеры
float width = maxX - minX;
float height = maxY - minY;
float centerX = (minX + maxX) * 0.5f;
float centerY = (minY + maxY) * 0.5f;
//width = width * 0.995;
//height = height * 0.995;
renderer.PushProjectionMatrix(
centerX - width*0.5, centerX + width * 0.5,
centerY - height * 0.5, centerY + height * 0.5,
150, 200000);
renderer.PushMatrix();
renderer.LoadIdentity();
// Сдвигаем камеру по Z
renderer.TranslateMatrix(Vector3f{ 0, 0, -45000 });
// Применяем вращение
renderer.RotateMatrix(mr);
// Извлекаем нормаль треугольника (это 3-й столбец нашей матрицы вращения)
Vector3f planeNormal = mr.col(2);
renderer.RenderUniform3fv("uPlanePoint", tr.data[0].data());
renderer.RenderUniform3fv("uPlaneNormal", planeNormal.data());
renderer.RenderUniform1f("uMaxHeight", StoneParams::BASE_SCALE * 1.1f); // Соответствует BASE_SCALE + perturbation
glActiveTexture(GL_TEXTURE0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK); // Отсекаем задние грани
if (stoneToBake.data.PositionData.size() > 0)
{
glBindTexture(GL_TEXTURE_2D, stoneTexture->getTexID());
renderer.DrawVertexRenderStruct(stoneToBake);
CheckGlError();
}
glDisable(GL_CULL_FACE); // Не забываем выключить, чтобы не сломать остальной рендер
renderer.PopMatrix();
renderer.PopProjectionMatrix();
renderer.shaderManager.PopShader();
CheckGlError();
}
void PlanetObject::draw(Renderer& renderer) {
{
if (stoneMapFB == nullptr)
{
//stoneMapFB = std::make_unique<FrameBuffer>(512, 512, true);
stoneMapFB = std::make_unique<FrameBuffer>(512, 512);
}
stoneMapFB->Bind();
bakeStoneTexture(renderer);
stoneMapFB->Unbind();
stoneMapFB->GenerateMipmaps();
}
glViewport(0, 0, Environment::width, Environment::height);
//--------------------------
drawPlanet(renderer);
drawStones(renderer);
//drawCamp(renderer);
glClear(GL_DEPTH_BUFFER_BIT);
drawAtmosphere(renderer);
}
void PlanetObject::drawPlanet(Renderer& renderer)
{
static const std::string planetLandShaderName = "planetLand";
static const std::string textureUniformName = "Texture";
renderer.shaderManager.PushShader(planetLandShaderName);
float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
auto zRange = planetData.calculateZRange(dist);
const float currentZNear = zRange.first;
const float currentZFar = zRange.second;
// 2. Применяем динамическую матрицу проекции
renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
currentZNear, currentZFar);
renderer.PushMatrix();
renderer.LoadIdentity();
renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
renderer.RotateMatrix(Environment::inverseShipMatrix);
renderer.TranslateMatrix(-Environment::shipState.position);
const Matrix4f viewMatrix = renderer.GetCurrentModelViewMatrix();
renderer.RenderUniform1i(textureUniformName, 0);
renderer.RenderUniform1i("BakedTexture", 1);
Triangle tr = planetData.getLodLevel().triangles[0]; // Берем базовый треугольник
Matrix3f mr = GetRotationForTriangle(tr); // Та же матрица, что и при запекании
// Позиция камеры (корабля) в мире
renderer.RenderUniform3fv("uViewPos", Environment::shipState.position.data());
//renderer.RenderUniform1f("uHeightScale", 0.08f);
renderer.RenderUniform1f("uHeightScale", 0.0f);
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
renderer.RenderUniform1f("uCurrentZFar", currentZFar);
// Направление на солнце в мировом пространстве
Vector3f sunDirWorld = Vector3f(1.0f, -1.0f, -1.0f).normalized();
renderer.RenderUniform3fv("uLightDirWorld", sunDirWorld.data());
// Направление от центра планеты к игроку для расчета дня/ночи
Vector3f playerDirWorld = Environment::shipState.position.normalized();
renderer.RenderUniform3fv("uPlayerDirWorld", playerDirWorld.data());
// Тот же фактор освещенности игрока
float playerLightFactor = playerDirWorld.dot(-sunDirWorld);
playerLightFactor = max(0.0f, (playerLightFactor + 0.2f) / 1.2f);
renderer.RenderUniform1f("uPlayerLightFactor", playerLightFactor);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, stoneMapFB->getTextureID());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, sandTexture->getTexID());
//glBindTexture(GL_TEXTURE_2D, stoneMapFB->getTextureID());
renderer.DrawVertexRenderStruct(planetRenderStruct);
CheckGlError();
renderer.PopMatrix();
renderer.PopProjectionMatrix();
renderer.shaderManager.PopShader();
CheckGlError();
}
void PlanetObject::drawStones(Renderer& renderer)
{
static const std::string planetStoneShaderName = "planetStone";
renderer.shaderManager.PushShader(planetStoneShaderName);
renderer.RenderUniform1i(textureUniformName, 0);
float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
auto zRange = planetData.calculateZRange(dist);
const float currentZNear = zRange.first;
const float currentZFar = zRange.second;
// 2. Применяем динамическую матрицу проекции
renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
currentZNear, currentZFar);
renderer.PushMatrix();
renderer.LoadIdentity();
renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
renderer.RotateMatrix(Environment::inverseShipMatrix);
renderer.TranslateMatrix(-Environment::shipState.position);
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
renderer.RenderUniform1f("uCurrentZFar", currentZFar);
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::shipState.position.normalized();
float playerLightFactor = max(0.0f, (playerDirWorld.dot(-sunDirWorld) + 0.2f) / 1.2f);
renderer.RenderUniform1f("uPlayerLightFactor", playerLightFactor);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, stoneTexture->getTexID());
/*
for (int i : triangleIndicesToDraw)
//for (int i = 0; i < stonesToRender.size(); i++)
{
if (stonesToRender[i].data.PositionData.size() > 0)
{
renderer.DrawVertexRenderStruct(stonesToRender[i]);
}
}*/
for (int i : triangleIndicesToDraw) {
// КРИТИЧЕСКОЕ ИЗМЕНЕНИЕ:
// Проверяем, что данные не просто существуют, а загружены в GPU
if (planetStones.statuses[i] == ChunkStatus::Live) {
// Дополнительная проверка на наличие данных (на всякий случай)
if (stonesToRender[i].data.PositionData.size() > 0) {
renderer.DrawVertexRenderStruct(stonesToRender[i]);
}
}
// Если статус Generating или Empty — мы просто пропускаем этот индекс.
// Камни появятся на экране плавно, как только отработает TaskManager и RefreshVBO.
}
CheckGlError();
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
renderer.PopMatrix();
renderer.PopProjectionMatrix();
renderer.shaderManager.PopShader();
CheckGlError();
}
void PlanetObject::drawAtmosphere(Renderer& renderer) {
static const std::string defaultShaderName = "defaultAtmosphere";
//glClear(GL_DEPTH_BUFFER_BIT);
glDepthMask(GL_FALSE);
renderer.shaderManager.PushShader(defaultShaderName);
float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
auto zRange = planetData.calculateZRange(dist);
float currentZNear = zRange.first;
float currentZFar = zRange.second;
if (currentZNear < 200)
{
currentZNear = 200;
currentZFar = currentZNear * 100;
}
// 2. Применяем динамическую матрицу проекции
renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
currentZNear, currentZFar);
renderer.PushMatrix();
renderer.LoadIdentity();
renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
renderer.RotateMatrix(Environment::inverseShipMatrix);
renderer.TranslateMatrix(-Environment::shipState.position);
const Matrix4f viewMatrix = renderer.GetCurrentModelViewMatrix();
Vector3f color = { 0.0, 0.5, 1.0 };
renderer.RenderUniform3fv("uColor", color.data());
renderer.RenderUniformMatrix4fv("ModelViewMatrix", false, viewMatrix.data());
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
// В начале drawAtmosphere или как uniform
//float time = SDL_GetTicks() / 1000.0f;
//renderer.RenderUniform1f("uTime", time);
// В методе PlanetObject::drawAtmosphere
Vector3f worldLightDir = Vector3f(1.0f, -1.0f, -1.0f).normalized();
// Получаем текущую матрицу вида (ModelView без трансляции объекта)
// В вашем движке это Environment::inverseShipMatrix
Matrix3f viewMatrix2 = Environment::inverseShipMatrix;
// Трансформируем вектор света в пространство вида
Vector3f viewLightDir = viewMatrix2 * worldLightDir;
// Передаем инвертированный вектор (направление НА источник)
Vector3f lightToSource = -viewLightDir.normalized();
renderer.RenderUniform3fv("uLightDirView", lightToSource.data());
// В методе Game::drawCubemap
//renderer.RenderUniform1f("uTime", SDL_GetTicks() / 1000.0f);
// Направление света в мировом пространстве для освещения облаков
//Vector3f worldLightDir = Vector3f(1.0f, -1.0f, -1.0f).normalized();
renderer.RenderUniform3fv("uWorldLightDir", worldLightDir.data());
// 1. Рассчитываем uPlayerLightFactor (как в Game.cpp)
Vector3f playerDirWorld = Environment::shipState.position.normalized();
Vector3f sunDirWorld = Vector3f(1.0f, -1.0f, -1.0f).normalized();
// Насколько игрок на свету
float playerLightFactor = playerDirWorld.dot(-sunDirWorld);
playerLightFactor = max(0.0f, (playerLightFactor + 0.2f) / 1.2f); // Мягкий порог
// 2. ОБЯЗАТЕЛЬНО передаем в шейдер
renderer.RenderUniform1f("uPlayerLightFactor", playerLightFactor);
// 3. Убедитесь, что uSkyColor тоже передан (в коде выше его не было)
renderer.RenderUniform3fv("uSkyColor", color.data());
//Vector3f playerDirWorld = Environment::shipState.position.normalized();
renderer.RenderUniform3fv("uPlayerDirWorld", playerDirWorld.data());
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);// Аддитивное смешивание для эффекта свечения
renderer.DrawVertexRenderStruct(planetAtmosphereRenderStruct);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
renderer.PopMatrix();
renderer.PopProjectionMatrix();
renderer.shaderManager.PopShader();
CheckGlError();
}
void PlanetObject::drawCamp(Renderer& renderer)
{
renderer.shaderManager.PushShader(defaultShaderName);
renderer.RenderUniform1i(textureUniformName, 0);
float dist = planetData.distanceToPlanetSurfaceFast(Environment::shipState.position);
auto zRange = planetData.calculateZRange(dist);
const float currentZNear = zRange.first;
const float currentZFar = zRange.second;
// 2. Применяем динамическую матрицу проекции
renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
currentZNear, currentZFar);
renderer.PushMatrix();
renderer.LoadIdentity();
renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
renderer.RotateMatrix(Environment::inverseShipMatrix);
renderer.TranslateMatrix(-Environment::shipState.position);
renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
renderer.RenderUniform1f("uCurrentZFar", currentZFar);
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::shipState.position.normalized();
float playerLightFactor = max(0.0f, (playerDirWorld.dot(-sunDirWorld) + 0.2f) / 1.2f);
renderer.RenderUniform1f("uPlayerLightFactor", playerLightFactor);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
for (int i = 0; i < planetData.campObjects.size(); i++)
{
renderer.PushMatrix();
for (int j = 0; j < 5; j++)
{
renderer.PushMatrix();
renderer.TranslateMatrix(planetData.campObjects[i].position);
renderer.RotateMatrix(planetData.campObjects[i].rotation);
renderer.ScaleMatrix(Vector3f{ 2.0f, 2.0f, 2.0f });
renderer.TranslateMatrix(planetData.campObjects[i].platformPos[j]);
glBindTexture(GL_TEXTURE_2D, campPlatformTexture->getTexID());
renderer.DrawVertexRenderStruct(campPlatform);
renderer.PopMatrix();
}
renderer.PopMatrix();
}
CheckGlError();
glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
renderer.PopMatrix();
renderer.PopProjectionMatrix();
renderer.shaderManager.PopShader();
CheckGlError();
glClear(GL_DEPTH_BUFFER_BIT);
}
float PlanetObject::distanceToPlanetSurface(const Vector3f& viewerPosition)
{
return planetData.distanceToPlanetSurfaceFast(viewerPosition);
}
} // namespace ZL

69
src/planet/PlanetObject.h
View File

@ -1,69 +0,0 @@
#pragma once
#include "render/Renderer.h"
#include "render/TextureManager.h"
#include <vector>
#include <chrono>
#include <iostream>
#include <string>
#include <array>
#include <numeric>
#include <random>
#include <algorithm>
#include <map>
#include <set>
#include "utils/Perlin.h"
#include "PlanetData.h"
#include "StoneObject.h"
#include "render/FrameBuffer.h"
#include <queue>
#include <mutex>
namespace ZL {
class TaskManager;
class MainThreadHandler;
class PlanetObject {
public:
PlanetData planetData;
// Данные только для рендеринга (OpenGL specific)
VertexRenderStruct planetRenderStruct;
VertexRenderStruct planetAtmosphereRenderStruct;
StoneGroup planetStones;
std::vector<VertexRenderStruct> stonesToRender;
VertexRenderStruct stoneToBake;
std::vector<int> triangleIndicesToDraw;
std::shared_ptr<Texture> sandTexture;
std::shared_ptr<Texture> stoneTexture;
std::unique_ptr<FrameBuffer> stoneMapFB;
VertexRenderStruct campPlatform;
std::shared_ptr<Texture> campPlatformTexture;
Vector3f lastUpdatePos;
// External items, set outside
Renderer& renderer;
TaskManager& taskManager;
MainThreadHandler& mainThreadHandler;
public:
PlanetObject(Renderer& iRenderer, TaskManager& iTaskManager, MainThreadHandler& iMainThreadHandler);
void init();
void update(float deltaTimeMs);
void bakeStoneTexture(Renderer& renderer);
void draw(Renderer& renderer);
void drawStones(Renderer& renderer);
void drawPlanet(Renderer& renderer);
void drawAtmosphere(Renderer& renderer);
void drawCamp(Renderer& renderer);
float distanceToPlanetSurface(const Vector3f& viewerPosition);
};
} // namespace ZL

354
src/planet/StoneObject.cpp
View File

@ -1,354 +0,0 @@
#include "StoneObject.h"
#include "utils/Utils.h"
#include <random>
#include <cmath>
#include "render/Renderer.h"
#include "PlanetData.h"
namespace ZL {
#if defined EMSCRIPTEN || defined __ANDROID__
using std::min;
using std::max;
#endif
const float StoneParams::BASE_SCALE = 10.0f; // Общий размер камня
const float StoneParams::MIN_AXIS_SCALE = 1.0f; // Минимальное растяжение/сжатие по оси
const float StoneParams::MAX_AXIS_SCALE = 1.0f; // Максимальное растяжение/сжатие по оси
const float StoneParams::MIN_PERTURBATION = 0.0f; // Минимальное радиальное возмущение вершины
const float StoneParams::MAX_PERTURBATION = 0.0f; // Максимальное радиальное возмущение вершины
const int StoneParams::STONES_PER_TRIANGLE = 40;
// Вспомогательная функция для получения случайного числа в диапазоне [min, max]
float getRandomFloat(std::mt19937& gen, float min, float max) {
std::uniform_real_distribution<> distrib(min, max);
return static_cast<float>(distrib(gen));
}
// Вспомогательная функция для генерации случайной точки на треугольнике
// Использует барицентрические координаты
Vector3f GetRandomPointOnTriangle(const Triangle& t, std::mt19937& engine) {
std::uniform_real_distribution<> distrib(0.0f, 1.0f);
float r1 = getRandomFloat(engine, 0.0f, 1.0f);
float r2 = getRandomFloat(engine, 0.0f, 1.0f);
// Преобразование r1, r2 для получения равномерного распределения
float a = 1.0f - std::sqrt(r1);
float b = std::sqrt(r1) * r2;
float c = 1.0f - a - b; // c = sqrt(r1) * (1 - r2)
// Барицентрические координаты
// P = a*p1 + b*p2 + c*p3
Vector3f p1_term = t.data[0] * a;
Vector3f p2_term = t.data[1] * b;
Vector3f p3_term = t.data[2] * c;
return p1_term + p2_term + p3_term;
}
// Икосаэдр (на основе золотого сечения phi)
// Координаты могут быть вычислены заранее для константного икосаэдра.
// Здесь только объявление, чтобы показать идею.
VertexDataStruct CreateBaseConvexPolyhedron(uint64_t seed) {
// const size_t SUBDIVISION_LEVEL = 1; // Уровень подразделения (для более круглого камня, пока опустим)
std::mt19937 engine(static_cast<unsigned int>(seed));
// Золотое сечение
const float t = (1.0f + std::sqrt(5.0f)) / 2.0f;
// 12 вершин икосаэдра
std::vector<Vector3f> initialVertices = {
{ -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 }
};
// 20 треугольных граней (индексы вершин)
std::vector<std::array<int, 3>> faces = {
// 5 треугольников вокруг вершины 0
{0, 11, 5}, {0, 5, 1}, {0, 1, 7}, {0, 7, 10}, {0, 10, 11},
// 5 смежных полос
{1, 5, 9}, {5, 11, 4}, {11, 10, 2}, {10, 7, 6}, {7, 1, 8},
// 5 треугольников вокруг вершины 3
{3, 9, 4}, {3, 4, 2}, {3, 2, 6}, {3, 6, 8}, {3, 8, 9},
// 5 смежных полос
{4, 9, 5}, {2, 4, 11}, {6, 2, 10}, {8, 6, 7}, {9, 8, 1}
};
// 1. Нормализация и Возмущение (Perturbation)
for (Vector3f& v : initialVertices) {
v = v.normalized() * StoneParams::BASE_SCALE; // Нормализация к сфере радиуса BASE_SCALE
// Радиальное возмущение:
float perturbation = getRandomFloat(engine, StoneParams::MIN_PERTURBATION, StoneParams::MAX_PERTURBATION);
v = v * (1.0f + perturbation);
}
// 2. Трансформация (Масштабирование и Поворот)
// Случайные масштабы по осям
Vector3f scaleFactors = {
getRandomFloat(engine, StoneParams::MIN_AXIS_SCALE, StoneParams::MAX_AXIS_SCALE),
getRandomFloat(engine, StoneParams::MIN_AXIS_SCALE, StoneParams::MAX_AXIS_SCALE),
getRandomFloat(engine, StoneParams::MIN_AXIS_SCALE, StoneParams::MAX_AXIS_SCALE)
};
// Применяем масштабирование
for (Vector3f& v : initialVertices) {
v(0) *= scaleFactors(0);
v(1) *= scaleFactors(1);
v(2) *= scaleFactors(2);
}
/*
// Случайный поворот (например, вокруг трех осей)
Vector4f qx = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitX()));//QuatFromRotateAroundX(getRandomFloat(engine, 0.0f, 360.0f));
Vector4f qy = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitY()));//QuatFromRotateAroundY(getRandomFloat(engine, 0.0f, 360.0f));
Vector4f qz = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitZ()));//QuatFromRotateAroundZ(getRandomFloat(engine, 0.0f, 360.0f));
Vector4f qFinal = slerp(qx, qy, 0.5f); // Простой пример комбинирования
qFinal = slerp(qFinal, qz, 0.5f).normalized();
Matrix3f rotationMatrix = QuatToMatrix(qFinal);
for (Vector3f& v : initialVertices) {
v = MultMatrixVector(rotationMatrix, v);
}*/
// 3. Сглаженные Нормали и Формирование Mesh
VertexDataStruct result;
// Карта для накопления нормалей по уникальным позициям вершин
// (Требует определенного оператора < для Vector3f в ZLMath.h, который у вас есть)
std::map<Vector3f, Vector3f, Vector3fComparator> smoothNormalsMap;
// Предварительное заполнение карты нормалями
for (const auto& face : faces) {
Vector3f p1 = initialVertices[face[0]];
Vector3f p2 = initialVertices[face[1]];
Vector3f p3 = initialVertices[face[2]];
// Нормаль грани: (p2 - p1) x (p3 - p1)
Vector3f faceNormal = (p2 - p1).cross(p3 - p1).normalized();
smoothNormalsMap[p1] = smoothNormalsMap[p1] + faceNormal;
smoothNormalsMap[p2] = smoothNormalsMap[p2] + faceNormal;
smoothNormalsMap[p3] = smoothNormalsMap[p3] + faceNormal;
}
// Нормализация накопленных нормалей
for (auto& pair : smoothNormalsMap) {
pair.second = pair.second.normalized();
}
// 4. Финальное заполнение VertexDataStruct и Текстурные Координаты
for (const auto& face : faces) {
Vector3f p1 = initialVertices[face[0]];
Vector3f p2 = initialVertices[face[1]];
Vector3f p3 = initialVertices[face[2]];
// Позиции
result.PositionData.push_back(p1);
result.PositionData.push_back(p2);
result.PositionData.push_back(p3);
// Сглаженные Нормали (из карты)
result.NormalData.push_back(smoothNormalsMap[p1]);
result.NormalData.push_back(smoothNormalsMap[p2]);
result.NormalData.push_back(smoothNormalsMap[p3]);
// Текстурные Координаты (Планарная проекция на плоскость грани)
// p1 -> (0, 0), p2 -> (L_12, 0), p3 -> (L_13 * cos(angle), L_13 * sin(angle))
// Где L_xy - длина вектора, angle - угол между p2-p1 и p3-p1
Vector3f uAxis = (p2 - p1).normalized();
Vector3f vRaw = p3 - p1;
// Проекция vRaw на uAxis
float uProjLen = vRaw.dot(uAxis);
// Вектор V перпендикулярный U: vRaw - uProj
Vector3f vAxisRaw = vRaw - (uAxis * uProjLen);
// Длина оси V
float vLen = vAxisRaw.norm();
// Нормализованная ось V
Vector3f vAxis = vAxisRaw.normalized();
// Координаты (u, v) для p1, p2, p3 относительно p1
Vector2f uv1 = { 0.0f, 0.0f };
Vector2f uv2 = { (p2 - p1).norm(), 0.0f }; // p2-p1 вдоль оси U
Vector2f uv3 = { uProjLen, vLen }; // p3-p1: u-компонента = uProjLen, v-компонента = vLen
// Находим максимальный размер, чтобы масштабировать в [0, 1]
float maxUV = max(uv2(0), max(uv3(0), uv3(1)));
if (maxUV > 0.000001f) {
// Масштабируем:
result.TexCoordData.push_back(uv1);
result.TexCoordData.push_back(uv2 * (1.f / maxUV));
result.TexCoordData.push_back(uv3 * (1.f / maxUV));
}
else {
// Предотвращение деления на ноль для вырожденных граней
result.TexCoordData.push_back({ 0.0f, 0.0f });
result.TexCoordData.push_back({ 0.0f, 0.0f });
result.TexCoordData.push_back({ 0.0f, 0.0f });
}
}
return result;
}
Triangle createLocalTriangle(const Triangle& sampleTri)
{
// Находим центр в 3D
Vector3f center = (sampleTri.data[0] + sampleTri.data[1] + sampleTri.data[2]) * (1.0f / 3.0f);
// Строим базис самого треугольника
// vY направляем на 0-ю вершину (как в вашем Special расчете)
Vector3f vY = (sampleTri.data[0] - center).normalized();
// Временный X для расчета нормали
Vector3f vX_temp = (sampleTri.data[1] - sampleTri.data[2]).normalized();
// Чистая нормаль
Vector3f vZ = vX_temp.cross(vY).normalized();
// Чистый X, перпендикулярный Y и Z
Vector3f vX = vY.cross(vZ).normalized();
// Переводим 3D точки в этот 2D базис (Z зануляется сам собой)
auto toLocal = [&](const Vector3f& p) {
Vector3f d = p - center;
return Vector3f{ d.dot(vX), d.dot(vY), 0.0f };
};
Triangle local;
local.data[0] = toLocal(sampleTri.data[0]);
local.data[1] = toLocal(sampleTri.data[1]);
local.data[2] = toLocal(sampleTri.data[2]);
return local;
}
StoneGroup CreateStoneGroupData(uint64_t globalSeed, const LodLevel& planetLodLevel) {
StoneGroup group;
group.allInstances.resize(planetLodLevel.triangles.size());
for (size_t tIdx = 0; tIdx < planetLodLevel.triangles.size(); ++tIdx) {
const Triangle& tri = planetLodLevel.triangles[tIdx];
std::mt19937 engine(static_cast<unsigned int>(globalSeed));
for (int i = 0; i < StoneParams::STONES_PER_TRIANGLE; ++i) {
StoneInstance instance;
instance.seed = globalSeed;// + tIdx * 1000 + i;
instance.position = GetRandomPointOnTriangle(tri, engine);
float SCALE_MIN = 0.75f;
float SCALE_MAX = 2.5f;
instance.scale = {
getRandomFloat(engine, SCALE_MIN, SCALE_MAX),
getRandomFloat(engine, SCALE_MIN, SCALE_MAX),
getRandomFloat(engine, SCALE_MIN, SCALE_MAX)
};
/*
if (tIdx == 0)
{
instance.scale = instance.scale * 0.7f;
}*/
/*
Vector4f qx = QuatFromRotateAroundX(getRandomFloat(engine, 0.0f, 360.0f));
Vector4f qy = QuatFromRotateAroundY(getRandomFloat(engine, 0.0f, 360.0f));
Vector4f qz = QuatFromRotateAroundZ(getRandomFloat(engine, 0.0f, 360.0f));
instance.rotation = slerp(slerp(qx, qy, 0.5f), qz, 0.5f).normalized();
*/
instance.rotation = Vector4f(0.f, 0.f, 0.f, 1.f);
group.allInstances[tIdx].push_back(instance);
}
}
return group;
}
std::vector<VertexRenderStruct> StoneGroup::inflate(int count)
{
std::vector<VertexRenderStruct> result;
result.resize(count);
for (int tIdx = 0; tIdx < count; tIdx++)
{
result[tIdx] = inflateOne(tIdx, 1.0f);
}
return result;
}
VertexRenderStruct StoneGroup::inflateOne(int index, float scaleModifier)
{
static VertexDataStruct baseStone = CreateBaseConvexPolyhedron(1337);
VertexRenderStruct result;
for (const auto& inst : allInstances[index]) {
Matrix3f rotMat = inst.rotation.toRotationMatrix();
for (size_t j = 0; j < baseStone.PositionData.size(); ++j) {
Vector3f p = baseStone.PositionData[j];
Vector3f n = baseStone.NormalData[j];
p(0) *= inst.scale(0) * scaleModifier;
p(1) *= inst.scale(1) * scaleModifier;
p(2) *= inst.scale(2) * scaleModifier;
result.data.PositionData.push_back(rotMat * p + inst.position);
result.data.NormalData.push_back(rotMat * n);
result.data.TexCoordData.push_back(baseStone.TexCoordData[j]);
}
result.RefreshVBO();
}
return result;
}
VertexDataStruct StoneGroup::inflateOneDataOnly(int index, float scaleModifier)
{
static VertexDataStruct baseStone = CreateBaseConvexPolyhedron(1337);
VertexDataStruct result;
for (const auto& inst : allInstances[index]) {
Matrix3f rotMat = inst.rotation.toRotationMatrix();
for (size_t j = 0; j < baseStone.PositionData.size(); ++j) {
Vector3f p = baseStone.PositionData[j];
Vector3f n = baseStone.NormalData[j];
p(0) *= inst.scale(0) * scaleModifier;
p(1) *= inst.scale(1) * scaleModifier;
p(2) *= inst.scale(2) * scaleModifier;
result.PositionData.push_back(rotMat * p + inst.position);
result.NormalData.push_back(rotMat * n);
result.TexCoordData.push_back(baseStone.TexCoordData[j]);
}
}
return result;
}
} // namespace ZL

57
src/planet/StoneObject.h
View File

@ -1,57 +0,0 @@
#pragma once
#include "render/Renderer.h"
#include "PlanetData.h"
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 int STONES_PER_TRIANGLE;
};
struct StoneInstance {
uint64_t seed;
Vector3f position;
Vector3f scale;
Eigen::Quaternionf rotation;
};
enum class ChunkStatus {
Empty, // Данных нет
Generating, // Задача в TaskManager (CPU)
ReadyToUpload, // Данные в памяти, ждут очереди в главный поток
Live // Загружено в GPU и готово к отрисовке
};
struct StoneGroup {
// mesh.PositionData и прочие будут заполняться в inflate()
VertexDataStruct mesh;
std::vector<std::vector<StoneInstance>> allInstances;
// Очищает старую геометрию и генерирует новую для указанных индексов
std::vector<VertexRenderStruct> inflate(int count);
VertexRenderStruct inflateOne(int index, float scaleModifier);
VertexDataStruct inflateOneDataOnly(int index, float scaleModifier);
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);
} // namespace ZL