西风逍遥游
811eff1c3a
- EVENGINE_ENABLE_STRICT_WARNINGS option: MSVC /W4 /WX, GCC/Clang -Wall -Wextra -Werror, with documented noise suppressions and -isystem/-external:I for third-party headers; enabled on the Windows/Linux debug CI jobs. - Fix warnings across engine, modules and tests exposed by the gate, including real bugs (incomplete-type deletes, Timespan microsecond overflow, overload hiding, enum switch gaps, dead code). - Add Linux ASan+UBSan job, example smoke step, python-tools test job, ruff config (scripts+tools), weekly Linux coverage job and a CodeQL workflow.
255 lines
9.6 KiB
C++
255 lines
9.6 KiB
C++
#include "virtualgeometry/VirtualGeometryRenderer.h"
|
|
#include "virtualgeometry/Builder.h"
|
|
|
|
#include "common/Exception.h"
|
|
#include "data/ByteData.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <vector>
|
|
|
|
namespace eve::virtualgeometry {
|
|
namespace {
|
|
|
|
// Minimal column-major mat4 helpers (GLM is not linked into this module).
|
|
struct Mat4 {
|
|
float m[16];
|
|
static Mat4 identity() {
|
|
Mat4 r{};
|
|
r.m[0] = r.m[5] = r.m[10] = r.m[15] = 1.f;
|
|
return r;
|
|
}
|
|
static Mat4 mul(const Mat4 &a, const Mat4 &b) {
|
|
Mat4 r{};
|
|
for (int c = 0; c < 4; ++c)
|
|
for (int row = 0; row < 4; ++row) {
|
|
float sum = 0;
|
|
for (int k = 0; k < 4; ++k) sum += a.m[k * 4 + row] * b.m[c * 4 + k];
|
|
r.m[c * 4 + row] = sum;
|
|
}
|
|
return r;
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
VirtualGeometryRenderer::VirtualGeometryRenderer() { vgCreate(backend_); }
|
|
|
|
VirtualGeometryRenderer::~VirtualGeometryRenderer() { vgDestroy(backend_); }
|
|
|
|
bool VirtualGeometryRenderer::build(const VirtualGeometryBuilder::MeshInput &in) {
|
|
VirtualGeometryBuilder builder;
|
|
bool ok = builder.build(in, builderOptions_, asset_);
|
|
if (!ok) return false;
|
|
vgReset(backend_, visibleCapacity_); // size visible/stats before upload
|
|
vgUpload(backend_, asset_);
|
|
return true;
|
|
}
|
|
|
|
bool VirtualGeometryRenderer::build(const float *positions, int vertexCount,
|
|
const std::uint32_t *indices, int indexCount) {
|
|
VirtualGeometryBuilder::MeshInput in;
|
|
in.vertexCount = vertexCount;
|
|
in.positions = positions;
|
|
in.indices = indices;
|
|
in.indexCount = indexCount;
|
|
return build(in);
|
|
}
|
|
|
|
namespace {
|
|
// Build a unit icosphere (triangulated) into CPU buffers.
|
|
void buildIco(std::vector<float> &positions, std::vector<std::uint32_t> &indices, int subdiv) {
|
|
positions.clear();
|
|
indices.clear();
|
|
struct F { int a, b, c; };
|
|
auto addVtx = [&](float x, float y, float z) {
|
|
float l = std::sqrt(x * x + y * y + z * z);
|
|
positions.push_back(x / l);
|
|
positions.push_back(y / l);
|
|
positions.push_back(z / l);
|
|
return static_cast<int>(positions.size() / 3) - 1;
|
|
};
|
|
auto tri = [&](int a, int b, int c) {
|
|
indices.push_back(static_cast<std::uint32_t>(a));
|
|
indices.push_back(static_cast<std::uint32_t>(b));
|
|
indices.push_back(static_cast<std::uint32_t>(c));
|
|
};
|
|
auto mid = [&](int i0, int i1) {
|
|
return addVtx(0.5f * (positions[3 * i0] + positions[3 * i1]),
|
|
0.5f * (positions[3 * i0 + 1] + positions[3 * i1 + 1]),
|
|
0.5f * (positions[3 * i0 + 2] + positions[3 * i1 + 2]));
|
|
};
|
|
const float t = (1.f + std::sqrt(5.f)) * 0.5f;
|
|
std::vector<std::array<float, 3>> base = {
|
|
{-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}};
|
|
int idx[12];
|
|
for (int i = 0; i < 12; ++i) idx[i] = addVtx(base[i][0], base[i][1], base[i][2]);
|
|
int faces[20][3] = {{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<F> cur;
|
|
for (auto &f : faces) cur.push_back({idx[f[0]], idx[f[1]], idx[f[2]]});
|
|
for (int d = 0; d < subdiv; ++d) {
|
|
std::vector<F> nf;
|
|
for (auto &x : cur) {
|
|
int ab = mid(x.a, x.b), ac = mid(x.a, x.c), bc = mid(x.b, x.c);
|
|
nf.push_back({x.a, ab, ac});
|
|
nf.push_back({ab, x.b, bc});
|
|
nf.push_back({ac, bc, x.c});
|
|
nf.push_back({ab, bc, ac});
|
|
}
|
|
cur.swap(nf);
|
|
}
|
|
for (auto &x : cur) tri(x.a, x.b, x.c);
|
|
}
|
|
} // namespace
|
|
|
|
bool VirtualGeometryRenderer::buildIcosphere(int subdiv) {
|
|
std::vector<float> pos;
|
|
std::vector<std::uint32_t> idx;
|
|
buildIco(pos, idx, std::clamp(subdiv, 1, 6));
|
|
return build(pos.data(), static_cast<int>(pos.size() / 3), idx.data(),
|
|
static_cast<int>(idx.size()));
|
|
}
|
|
|
|
void VirtualGeometryRenderer::setViewport(int width, int height, float fovYDeg, float errorPx) {
|
|
width_ = std::max(1, width);
|
|
height_ = std::max(1, height);
|
|
uniforms_.params[0] = static_cast<float>(width_);
|
|
uniforms_.params[1] = static_cast<float>(height_);
|
|
uniforms_.params[2] = static_cast<float>(height_) /
|
|
(2.f * std::tan(fovYDeg * 3.14159265358979323846f / 360.f));
|
|
uniforms_.params[3] = errorPx;
|
|
}
|
|
|
|
void VirtualGeometryRenderer::setCamera(const float view[16], const float proj[16],
|
|
const float model[16], const float camPos[3]) {
|
|
// Combined view-projection: clip = P * V * model * pos. The shader uses
|
|
// vgU.viewProj * (vgU.model * pos), so viewProj = P * V.
|
|
Mat4 p;
|
|
for (int i = 0; i < 16; ++i) p.m[i] = proj[i];
|
|
Mat4 v;
|
|
for (int i = 0; i < 16; ++i) v.m[i] = view[i];
|
|
Mat4 vp = Mat4::mul(p, v);
|
|
for (int i = 0; i < 16; ++i) uniforms_.viewProj[i] = vp.m[i];
|
|
for (int i = 0; i < 16; ++i) uniforms_.model[i] = model ? model[i] : Mat4::identity().m[i];
|
|
uniforms_.cameraPos[0] = camPos[0];
|
|
uniforms_.cameraPos[1] = camPos[1];
|
|
uniforms_.cameraPos[2] = camPos[2];
|
|
uniforms_.cameraPos[3] = 0.f;
|
|
updateUniforms();
|
|
}
|
|
|
|
void VirtualGeometryRenderer::setCameraSimple(float camX, float camY, float camZ, float nearZ,
|
|
float farZ) {
|
|
const float fovY = (uniforms_.params[2] > 0.f)
|
|
? 2.f * std::atan(static_cast<float>(height_) / (2.f * uniforms_.params[2]))
|
|
: 60.f * 3.14159265358979323846f / 180.f;
|
|
// Identity view (looking down -Z).
|
|
Mat4 view = Mat4::identity();
|
|
// Perspective projection (column-major, D3D/Vulkan clip z in [0,1]).
|
|
Mat4 proj{};
|
|
const float a = 1.f / std::tan(fovY * 0.5f);
|
|
const float aspect = static_cast<float>(width_) / static_cast<float>(height_);
|
|
proj.m[0] = a / aspect;
|
|
proj.m[5] = a;
|
|
proj.m[10] = farZ / (nearZ - farZ);
|
|
proj.m[11] = -1.f;
|
|
proj.m[14] = (nearZ * farZ) / (nearZ - farZ);
|
|
const float camPos[3] = {camX, camY, camZ};
|
|
setCamera(view.m, proj.m, nullptr, camPos);
|
|
}
|
|
|
|
void VirtualGeometryRenderer::setModelYaw(float yaw) { modelYaw_ = yaw; }
|
|
|
|
void VirtualGeometryRenderer::updateUniforms() {
|
|
uniforms_.misc[0] = static_cast<float>(static_cast<int>(asset_.clusters.size()));
|
|
if (modelYaw_ != 0.f) {
|
|
// Build a Y-rotation model matrix (column-major) and override.
|
|
float c = std::cos(modelYaw_), s = std::sin(modelYaw_);
|
|
Mat4 r = Mat4::identity();
|
|
r.m[0] = c; r.m[2] = s;
|
|
r.m[8] = -s; r.m[10] = c;
|
|
for (int i = 0; i < 16; ++i) uniforms_.model[i] = r.m[i];
|
|
}
|
|
// Recompute per-cluster screen-space error constants (errorR * projScale).
|
|
for (auto &c : asset_.clusters) c.errorRScreen = c.errorR * uniforms_.params[2];
|
|
vgUploadUniforms(backend_, uniforms_);
|
|
}
|
|
|
|
int VirtualGeometryRenderer::update() {
|
|
int clusters = static_cast<int>(asset_.clusters.size());
|
|
if (clusters <= 0 || !backend_.state) return 0;
|
|
lastVisible_ = vgUpdate(backend_, clusters, visibleCapacity_, width_, height_);
|
|
return lastVisible_;
|
|
}
|
|
|
|
bool VirtualGeometryRenderer::resolve(unsigned char *outRgba, int &outW, int &outH) {
|
|
std::vector<std::uint32_t> pix;
|
|
if (!vgReadPixels(backend_, pix)) return false;
|
|
outW = width_;
|
|
outH = height_;
|
|
const int n = outW * outH;
|
|
for (int i = 0; i < n; ++i) {
|
|
std::uint32_t packed = pix[i];
|
|
std::uint32_t depth = packed >> 16;
|
|
std::uint32_t cid = packed & 0xFFFFu;
|
|
if (cid == 0u && depth == 0xFFFFu) {
|
|
outRgba[4 * i + 0] = 4;
|
|
outRgba[4 * i + 1] = 6;
|
|
outRgba[4 * i + 2] = 12;
|
|
outRgba[4 * i + 3] = 255;
|
|
continue;
|
|
}
|
|
// Stable per-cluster color hash.
|
|
std::uint32_t h = cid * 2654435761u;
|
|
float cr = static_cast<float>((h >> 16) & 0xFFu),
|
|
cg = static_cast<float>((h >> 8) & 0xFFu),
|
|
cb = static_cast<float>(h & 0xFFu);
|
|
float mx = std::max({cr, cg, cb, 1.f});
|
|
float depthF = static_cast<float>(depth) / 65535.f;
|
|
float shade = 0.35f + 0.65f * (1.f - depthF);
|
|
outRgba[4 * i + 0] = static_cast<unsigned char>(cr / mx * 255.f * shade);
|
|
outRgba[4 * i + 1] = static_cast<unsigned char>(cg / mx * 255.f * shade);
|
|
outRgba[4 * i + 2] = static_cast<unsigned char>(cb / mx * 255.f * shade);
|
|
outRgba[4 * i + 3] = 255;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
eve::data::ByteData *VirtualGeometryRenderer::resolveByteData() {
|
|
int w = 1, h = 1;
|
|
auto *bd = new eve::data::ByteData(static_cast<std::size_t>(width_) * height_ * 4);
|
|
if (!bd) return nullptr;
|
|
if (!resolve(static_cast<unsigned char *>(bd->getData()), w, h)) {
|
|
delete bd;
|
|
return nullptr;
|
|
}
|
|
return bd;
|
|
}
|
|
|
|
int VirtualGeometryRenderer::getClusterCount() const {
|
|
return static_cast<int>(asset_.clusters.size());
|
|
}
|
|
|
|
int VirtualGeometryRenderer::getTotalTriangleCount() const {
|
|
return asset_.totalTriangles();
|
|
}
|
|
|
|
int VirtualGeometryRenderer::getLodLevel(int clusterId) const {
|
|
if (clusterId < 0 || static_cast<std::size_t>(clusterId) >= asset_.clusters.size()) return -1;
|
|
return static_cast<int>(asset_.clusters[clusterId].lodLevel);
|
|
}
|
|
|
|
int VirtualGeometryRenderer::getMaxLodLevel() const {
|
|
int m = 0;
|
|
for (const auto &c : asset_.clusters) m = std::max(m, static_cast<int>(c.lodLevel));
|
|
return m;
|
|
}
|
|
|
|
} // namespace eve::virtualgeometry
|