Refactoring
This commit is contained in:
Vladislav Khorev
parent
2ef2e456f7
commit
f2f56125f0
@ -36,41 +36,24 @@ add_executable(space-game001
|
||||
../src/utils/Utils.h
|
||||
../src/SparkEmitter.cpp
|
||||
../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.h
|
||||
../src/utils/TaskManager.cpp
|
||||
../src/utils/TaskManager.h
|
||||
# ../src/planet/StoneObject.cpp
|
||||
# ../src/planet/StoneObject.h
|
||||
../src/render/FrameBuffer.cpp
|
||||
../src/render/FrameBuffer.h
|
||||
../src/render/ShadowMap.cpp
|
||||
../src/render/ShadowMap.h
|
||||
../src/UiManager.cpp
|
||||
../src/UiManager.h
|
||||
../src/Projectile.h
|
||||
../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/Projectile.h
|
||||
# ../src/Projectile.cpp
|
||||
../src/render/TextRenderer.h
|
||||
../src/render/TextRenderer.cpp
|
||||
../src/MenuManager.h
|
||||
../src/MenuManager.cpp
|
||||
# ../src/Space.h
|
||||
# ../src/Space.cpp
|
||||
../src/Location.h
|
||||
../src/Location.cpp
|
||||
../src/GameConstants.h
|
||||
../src/GameConstants.cpp
|
||||
../src/ScriptEngine.h
|
||||
@ -115,8 +98,6 @@ target_compile_definitions(space-game001 PRIVATE
|
||||
SDL_MAIN_HANDLED
|
||||
# DEBUG_LIGHT
|
||||
# SHOW_PATH
|
||||
# NETWORK
|
||||
# SIMPLIFIED
|
||||
)
|
||||
|
||||
# Линкуем с SDL2main, если он вообще установлен
|
||||
|
||||
@ -70,8 +70,8 @@ public:
|
||||
bool canAttack = false;
|
||||
Character* attackTarget = nullptr;
|
||||
bool isPlayer = false;
|
||||
//bool useGpuSkinning = true;
|
||||
bool useGpuSkinning = false;
|
||||
bool useGpuSkinning = true;
|
||||
//bool useGpuSkinning = false;
|
||||
|
||||
float interactionRadius = 0.0f;
|
||||
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
#include "Game.h"
|
||||
#include "AnimatedModel.h"
|
||||
#include "BoneAnimatedModel.h"
|
||||
#include "planet/PlanetData.h"
|
||||
#include "utils/Utils.h"
|
||||
#include "render/OpenGlExtensions.h"
|
||||
#include <iostream>
|
||||
|
||||
@ -5,9 +5,7 @@
|
||||
#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 "items/GameObjectLoader.h"
|
||||
#include "items/Item.h"
|
||||
|
||||
2
src/Location.cpp
Normal file
2
src/Location.cpp
Normal file
@ -0,0 +1,2 @@
|
||||
#include "Location.h"
|
||||
|
||||
1
src/Location.h
Normal file
1
src/Location.h
Normal file
@ -0,0 +1 @@
|
||||
#pragma once
|
||||
2353
src/Space.cpp
2353
src/Space.cpp
File diff suppressed because it is too large
Load Diff
204
src/Space.h
204
src/Space.h
@ -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
|
||||
@ -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]];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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
|
||||
Loading…
Reference in New Issue
Block a user