mirror of
https://github.com/DarkflameUniverse/DarkflameServer.git
synced 2026-10-02 10:53:44 +00:00
7c32779e89
- The client puts a shape in its sorted, blended pass only when its NiMaterialProperty alpha is under 0.99999 (ShaderCommon::GetAlphaFlags 0x0109f5a0; the NiAlphaProperty blend flag isn't read); at 1.0 it's drawn solid with blending off. Transparent (and transparent glitter) shapes now get a material with alpha 0.9999, as the S01_Alpha shapes of the game's own brick models (res/BrickModels/ndmade) do; opaque shapes keep 1.0. Models with a transparent brick change; the others are byte for byte the same. - dUgcServer's files move into Bricks/, Model/, Render/, Formats/ and Processing/ (the CMakeLists says what each holds); includes are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
724 lines
29 KiB
C++
724 lines
29 KiB
C++
#include "UgcHsr.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <numeric>
|
|
|
|
#include "UgcThrottle.h"
|
|
|
|
namespace {
|
|
constexpr float INF = std::numeric_limits<float>::infinity();
|
|
constexpr float PI = 3.14159265358979f;
|
|
// Blender's default Glossy bounces (LU Toolbox leaves it)
|
|
constexpr int GLOSSY_BOUNCES = 4;
|
|
// Points on one triangle at most (very big triangles get their points further apart)
|
|
constexpr size_t MAX_POINTS = 4096;
|
|
|
|
// PCG32 (O'Neill), seeded per path so every path is the same whatever order they're traced in
|
|
class Random {
|
|
public:
|
|
explicit Random(uint64_t seed) {
|
|
m_State = 0;
|
|
Next();
|
|
m_State += seed;
|
|
Next();
|
|
}
|
|
|
|
uint32_t Next() {
|
|
const uint64_t old = m_State;
|
|
m_State = old * 6364136223846793005ull + 1442695040888963407ull;
|
|
const auto xorshifted = static_cast<uint32_t>(((old >> 18u) ^ old) >> 27u);
|
|
const auto rot = static_cast<uint32_t>(old >> 59u);
|
|
return (xorshifted >> rot) | (xorshifted << ((32u - rot) & 31u));
|
|
}
|
|
|
|
// In [0, 1)
|
|
float Float() { return static_cast<float>(Next() >> 8) * (1.0f / 16777216.0f); }
|
|
|
|
private:
|
|
uint64_t m_State;
|
|
};
|
|
|
|
uint64_t Mix(uint64_t h) {
|
|
h ^= h >> 33;
|
|
h *= 0xff51afd7ed558ccdull;
|
|
h ^= h >> 33;
|
|
h *= 0xc4ceb9fe1a85ec53ull;
|
|
h ^= h >> 33;
|
|
return h;
|
|
}
|
|
|
|
uint64_t PathSeed(uint64_t seed, uint64_t triangle, uint64_t point, uint64_t sample) {
|
|
return Mix(Mix(Mix(seed ^ 0x9E3779B97F4A7C15ull) ^ triangle) ^ (point << 16 | sample));
|
|
}
|
|
|
|
// Directions around a unit normal (Duff et al., "Building an Orthonormal Basis, Revisited")
|
|
void Basis(const glm::vec3& n, glm::vec3& t, glm::vec3& b) {
|
|
const float sign = std::copysign(1.0f, n.z);
|
|
const float a = -1.0f / (sign + n.z);
|
|
const float c = n.x * n.y * a;
|
|
t = glm::vec3(1.0f + sign * n.x * n.x * a, sign * c, -sign * n.x);
|
|
b = glm::vec3(c, sign + n.y * n.y * a, -n.y);
|
|
}
|
|
|
|
glm::vec3 CosineHemisphere(const glm::vec3& n, float u, float v) {
|
|
glm::vec3 t, b;
|
|
Basis(n, t, b);
|
|
const float r = std::sqrt(u), phi = 2.0f * PI * v;
|
|
return t * (r * std::cos(phi)) + b * (r * std::sin(phi)) + n * std::sqrt(std::max(0.0f, 1.0f - u));
|
|
}
|
|
|
|
/**
|
|
* Cycles' ensure_valid_reflection, which the Principled BSDF applies to its normal: N turned towards Ng just
|
|
* enough that the mirror reflection of I (towards where the light goes) stays above the surface.
|
|
*/
|
|
glm::vec3 EnsureValidReflection(const glm::vec3& ng, const glm::vec3& i, const glm::vec3& n) {
|
|
const auto r = 2.0f * glm::dot(n, i) * n - i;
|
|
const float threshold = std::min(0.9f * glm::dot(ng, i), 0.01f);
|
|
if (glm::dot(ng, r) >= threshold) return n;
|
|
const float ndotng = glm::dot(n, ng);
|
|
const auto x = glm::normalize(n - ndotng * ng);
|
|
const float ix = glm::dot(i, x), iz = glm::dot(i, ng);
|
|
const float ix2 = ix * ix, iz2 = iz * iz;
|
|
const float a = ix2 + iz2;
|
|
const float b = std::sqrt(std::max(ix2 * (a - threshold * threshold), 0.0f));
|
|
const float c = iz * threshold + a;
|
|
const float fac = 0.5f / a;
|
|
const float n1z2 = fac * (b + c), n2z2 = fac * (-b + c);
|
|
bool valid1 = n1z2 > 1e-5f && n1z2 <= 1.0f + 1e-5f;
|
|
bool valid2 = n2z2 > 1e-5f && n2z2 <= 1.0f + 1e-5f;
|
|
const auto root = [](float v) { return std::sqrt(std::max(v, 0.0f)); };
|
|
glm::vec2 chosen;
|
|
if (valid1 && valid2) {
|
|
const glm::vec2 n1(root(1.0f - n1z2), root(n1z2)), n2(root(1.0f - n2z2), root(n2z2));
|
|
const float r1 = 2.0f * (n1.x * ix + n1.y * iz) * n1.y - iz;
|
|
const float r2 = 2.0f * (n2.x * ix + n2.y * iz) * n2.y - iz;
|
|
valid1 = r1 >= 1e-5f;
|
|
valid2 = r2 >= 1e-5f;
|
|
if (valid1 && valid2) chosen = r1 < r2 ? n1 : n2;
|
|
else chosen = r1 > r2 ? n1 : n2;
|
|
} else if (valid1 || valid2) {
|
|
const float z2 = valid1 ? n1z2 : n2z2;
|
|
chosen = glm::vec2(root(1.0f - z2), root(z2));
|
|
} else {
|
|
return ng;
|
|
}
|
|
return chosen.x * x + chosen.y * ng;
|
|
}
|
|
|
|
float SchlickFresnel(float u) {
|
|
const float m = std::clamp(1.0f - u, 0.0f, 1.0f);
|
|
const float m2 = m * m;
|
|
return m2 * m2 * m;
|
|
}
|
|
|
|
float FresnelDielectricCos(float cosi, float eta) {
|
|
const float c = std::abs(cosi);
|
|
float g = eta * eta - 1.0f + c * c;
|
|
if (!(g > 0.0f)) return 1.0f;
|
|
g = std::sqrt(g);
|
|
const float a = (g - c) / (g + c);
|
|
const float b = (c * (g + c) - 1.0f) / (c * (g - c) + 1.0f);
|
|
return 0.5f * a * a * (1.0f + b * b);
|
|
}
|
|
|
|
/**
|
|
* The bake material: a new material's Principled BSDF (Blender 3.1: base color 0.8, specular 0.5, roughness 0.5,
|
|
* GGX) as Cycles 3.1 samples it, a diffuse closure (Burley, with retro-reflection) and a specular one (GGX with a
|
|
* dielectric Fresnel, IOR 1.5) picked by their sample weights. Only the directions a path takes and its throughput
|
|
* (for the Russian roulette) matter here.
|
|
*/
|
|
class Principled {
|
|
public:
|
|
static constexpr float BASE = 0.8f; // Base Color
|
|
static constexpr float ROUGHNESS = 0.5f; // Roughness
|
|
static constexpr float IOR = 1.5f; // (2 / (1 - sqrt(0.08 * Specular 0.5))) - 1
|
|
static constexpr float CSPEC0 = 0.04f; // Specular 0.5 * 0.08
|
|
|
|
// n: the material's normal (after EnsureValidReflection), i: towards where the path came from, ng: the
|
|
// geometric normal on the same side, sn: the shading normal. `first`: the bake point (Cycles' defensive
|
|
// sampling there); minRayPdf: the smallest bounce pdf so far (Cycles' Filter Glossy 1 blurs the specular)
|
|
Principled(const glm::vec3& n, const glm::vec3& i, const glm::vec3& ng, const glm::vec3& sn, bool first, float minRayPdf)
|
|
: m_N(n), m_I(i), m_Ng(ng), m_Sn(sn) {
|
|
m_F0 = FresnelDielectricCos(1.0f, IOR);
|
|
m_WeightDiffuse = BASE;
|
|
m_WeightSpecular = Fresnel(m_I, m_N); // the closure's weight 1 times its Fresnel color's average
|
|
if (first) {
|
|
const float sum = m_WeightDiffuse + m_WeightSpecular;
|
|
m_WeightDiffuse = std::max(m_WeightDiffuse, 0.125f * sum);
|
|
m_WeightSpecular = std::max(m_WeightSpecular, 0.125f * sum);
|
|
}
|
|
m_Alpha = std::clamp(ROUGHNESS * ROUGHNESS, 0.0f, 1.0f);
|
|
if (minRayPdf < 1.0f) m_Alpha = std::max(std::sqrt(1.0f - minRayPdf) * 0.5f, m_Alpha);
|
|
}
|
|
|
|
struct Sample {
|
|
glm::vec3 direction{};
|
|
float pdf{}; // of the mixture; 0: nothing sampled, the path ends
|
|
float throughput{}; // eval / pdf
|
|
bool glossy{};
|
|
};
|
|
|
|
Sample Draw(Random& random) const {
|
|
Sample sample;
|
|
const float pick = random.Float() * (m_WeightDiffuse + m_WeightSpecular);
|
|
const float u = random.Float(), v = random.Float();
|
|
float pdfDiffuse = 0.0f, pdfSpecular = 0.0f;
|
|
float eval = 0.0f;
|
|
if (pick < m_WeightDiffuse) {
|
|
sample.direction = CosineHemisphere(m_N, u, v);
|
|
if (!(glm::dot(m_Ng, sample.direction) > 0.0f)) return sample;
|
|
eval = EvalDiffuse(sample.direction, pdfDiffuse);
|
|
if (!(pdfDiffuse > 0.0f) || !(eval > 0.0f)) return sample;
|
|
if (!Transmission(sample.direction)) eval += EvalSpecular(sample.direction, pdfSpecular);
|
|
} else {
|
|
sample.glossy = true;
|
|
if (!SampleSpecular(u, v, sample.direction, eval, pdfSpecular)) return sample;
|
|
if (!Transmission(sample.direction)) eval += EvalDiffuse(sample.direction, pdfDiffuse);
|
|
}
|
|
sample.pdf = (pdfDiffuse * m_WeightDiffuse + pdfSpecular * m_WeightSpecular) / (m_WeightDiffuse + m_WeightSpecular);
|
|
sample.throughput = sample.pdf > 0.0f ? eval / sample.pdf : 0.0f;
|
|
return sample;
|
|
}
|
|
|
|
private:
|
|
// Cycles decides reflection or transmission by the shading normal; both closures only reflect
|
|
bool Transmission(const glm::vec3& l) const { return glm::dot(m_Sn, l) < 0.0f; }
|
|
|
|
float Fresnel(const glm::vec3& l, const glm::vec3& h) const {
|
|
const float fh = (FresnelDielectricCos(glm::dot(l, h), IOR) - m_F0) / (1.0f - m_F0);
|
|
return CSPEC0 * (1.0f - fh) + fh;
|
|
}
|
|
|
|
// bsdf_principled_diffuse_eval_reflect times the closure weight
|
|
float EvalDiffuse(const glm::vec3& l, float& pdf) const {
|
|
const float nl = glm::dot(m_N, l);
|
|
if (!(nl > 0.0f)) {
|
|
pdf = 0.0f;
|
|
return 0.0f;
|
|
}
|
|
pdf = nl / PI;
|
|
const float nv = glm::dot(m_N, m_I);
|
|
const float fv = SchlickFresnel(nv), fl = SchlickFresnel(nl);
|
|
float f = (1.0f - 0.5f * fv) * (1.0f - 0.5f * fl);
|
|
const float rr = ROUGHNESS * (glm::dot(l, m_I) + 1.0f);
|
|
f += rr * (fl + fv + fl * fv * (rr - 1.0f));
|
|
return BASE * nl / PI * f;
|
|
}
|
|
|
|
// bsdf_microfacet_ggx_eval_reflect (isotropic, Fresnel) times the closure weight 1
|
|
float EvalSpecular(const glm::vec3& l, float& pdf) const {
|
|
pdf = 0.0f;
|
|
const float cosNO = glm::dot(m_N, m_I), cosNI = glm::dot(m_N, l);
|
|
if (!(cosNI > 0.0f && cosNO > 0.0f) || m_Alpha * m_Alpha <= 1e-7f) return 0.0f;
|
|
const auto m = glm::normalize(l + m_I);
|
|
const float alpha2 = m_Alpha * m_Alpha;
|
|
const float cosThetaM = glm::dot(m_N, m);
|
|
const float cosThetaM2 = cosThetaM * cosThetaM;
|
|
const float tanThetaM2 = (1.0f - cosThetaM2) / cosThetaM2;
|
|
const float d = alpha2 / (PI * cosThetaM2 * cosThetaM2 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2));
|
|
const float g1o = 2.0f / (1.0f + std::sqrt(std::max(0.0f, 1.0f + alpha2 * (1.0f - cosNO * cosNO) / (cosNO * cosNO))));
|
|
const float g1i = 2.0f / (1.0f + std::sqrt(std::max(0.0f, 1.0f + alpha2 * (1.0f - cosNI * cosNI) / (cosNI * cosNI))));
|
|
const float common = d * 0.25f / cosNO;
|
|
pdf = g1o * common;
|
|
return Fresnel(l, m) * g1o * g1i * common;
|
|
}
|
|
|
|
// bsdf_microfacet_ggx_sample (isotropic): a visible normal (Heitz and d'Eon), the view reflected in it
|
|
bool SampleSpecular(float randu, float randv, glm::vec3& l, float& eval, float& pdf) const {
|
|
const float cosNO = glm::dot(m_N, m_I);
|
|
if (!(cosNO > 0.0f)) return false;
|
|
glm::vec3 x, y;
|
|
Basis(m_N, x, y);
|
|
// Stretch the view, sample the slopes, rotate and unstretch
|
|
auto local = glm::normalize(glm::vec3(m_Alpha * glm::dot(x, m_I), m_Alpha * glm::dot(y, m_I), cosNO));
|
|
float costheta = 1.0f, sintheta = 0.0f, cosphi = 1.0f, sinphi = 0.0f;
|
|
if (local.z < 0.99999f) {
|
|
costheta = local.z;
|
|
sintheta = std::sqrt(std::max(0.0f, 1.0f - costheta * costheta));
|
|
cosphi = local.x / sintheta;
|
|
sinphi = local.y / sintheta;
|
|
}
|
|
float slopeX, slopeY, g1o;
|
|
if (costheta >= 0.99999f) {
|
|
const float r = std::sqrt(randu / (1.0f - randu));
|
|
const float phi = 2.0f * PI * randv;
|
|
slopeX = r * std::cos(phi);
|
|
slopeY = r * std::sin(phi);
|
|
g1o = 1.0f;
|
|
} else {
|
|
const float tanThetaI = sintheta / costheta;
|
|
const float g1Inv = 0.5f * (1.0f + std::sqrt(std::max(0.0f, 1.0f + tanThetaI * tanThetaI)));
|
|
g1o = 1.0f / g1Inv;
|
|
const float a = 2.0f * randu * g1Inv - 1.0f;
|
|
const float aa = a * a;
|
|
const float tmp = 1.0f / (aa - 1.0f);
|
|
const float b = tanThetaI, bb = b * b;
|
|
const float dd = std::sqrt(std::max(0.0f, bb * (tmp * tmp) - (aa - bb) * tmp));
|
|
const float x1 = b * tmp - dd, x2 = b * tmp + dd;
|
|
slopeX = (a < 0.0f || x2 * tanThetaI > 1.0f) ? x1 : x2;
|
|
float s;
|
|
if (randv > 0.5f) {
|
|
s = 1.0f;
|
|
randv = 2.0f * (randv - 0.5f);
|
|
} else {
|
|
s = -1.0f;
|
|
randv = 2.0f * (0.5f - randv);
|
|
}
|
|
const float z = (randv * (randv * (randv * 0.27385f - 0.73369f) + 0.46341f)) / (randv * (randv * (randv * 0.093073f + 0.309420f) - 1.0f) + 0.597999f);
|
|
slopeY = s * z * std::sqrt(std::max(0.0f, 1.0f + slopeX * slopeX));
|
|
}
|
|
const float rotated = cosphi * slopeX - sinphi * slopeY;
|
|
slopeY = sinphi * slopeX + cosphi * slopeY;
|
|
slopeX = rotated * m_Alpha;
|
|
slopeY *= m_Alpha;
|
|
const auto localM = glm::normalize(glm::vec3(-slopeX, -slopeY, 1.0f));
|
|
const auto m = x * localM.x + y * localM.y + m_N * localM.z;
|
|
const float cosMO = glm::dot(m, m_I);
|
|
if (!(cosMO > 0.0f)) return false;
|
|
l = 2.0f * cosMO * m - m_I;
|
|
if (!(glm::dot(m_Ng, l) > 0.0f)) return false;
|
|
const float alpha2 = m_Alpha * m_Alpha;
|
|
const float cosThetaM2 = localM.z * localM.z;
|
|
const float tanThetaM2 = 1.0f / cosThetaM2 - 1.0f;
|
|
const float d = alpha2 / (PI * cosThetaM2 * cosThetaM2 * (alpha2 + tanThetaM2) * (alpha2 + tanThetaM2));
|
|
const float cosNI = glm::dot(m_N, l);
|
|
const float g1i = 2.0f / (1.0f + std::sqrt(std::max(0.0f, 1.0f + alpha2 * (1.0f - cosNI * cosNI) / (cosNI * cosNI))));
|
|
const float common = g1o * d * 0.25f / cosNO;
|
|
pdf = common;
|
|
eval = g1i * common * Fresnel(l, m);
|
|
return pdf > 0.0f && eval > 0.0f;
|
|
}
|
|
|
|
glm::vec3 m_N, m_I, m_Ng, m_Sn;
|
|
float m_F0{};
|
|
float m_WeightDiffuse{}, m_WeightSpecular{};
|
|
float m_Alpha{};
|
|
};
|
|
|
|
struct Hit {
|
|
float t{ INF };
|
|
uint32_t triangle{ UINT32_MAX };
|
|
float u{}, v{}; // weights of the triangle's second and third vertex
|
|
};
|
|
|
|
/**
|
|
* A bounding volume hierarchy (binned surface area heuristic) over a mesh's triangles, for the paths' rays: the
|
|
* nearest hit. A ray never hits the triangle it leaves (`skip`), as in Cycles.
|
|
*/
|
|
class Bvh {
|
|
public:
|
|
explicit Bvh(const UgcModel::Mesh& mesh) {
|
|
const size_t count = mesh.TriangleCount();
|
|
std::vector<uint32_t> order(count);
|
|
std::iota(order.begin(), order.end(), 0u);
|
|
std::vector<glm::vec3> lo(count), hi(count), centre(count);
|
|
for (size_t t = 0; t < count; t++) {
|
|
const auto& a = mesh.positions[mesh.indices[t * 3]];
|
|
const auto& b = mesh.positions[mesh.indices[t * 3 + 1]];
|
|
const auto& c = mesh.positions[mesh.indices[t * 3 + 2]];
|
|
lo[t] = glm::min(a, glm::min(b, c));
|
|
hi[t] = glm::max(a, glm::max(b, c));
|
|
centre[t] = (lo[t] + hi[t]) * 0.5f;
|
|
}
|
|
if (count > 0) Build(order, lo, hi, centre);
|
|
m_Triangles.reserve(count);
|
|
for (const auto t : order) {
|
|
const auto& a = mesh.positions[mesh.indices[t * 3]];
|
|
m_Triangles.push_back({ a, mesh.positions[mesh.indices[t * 3 + 1]] - a, mesh.positions[mesh.indices[t * 3 + 2]] - a, t });
|
|
}
|
|
}
|
|
|
|
// The nearest triangle along the ray (unit direction) before `maxT`
|
|
Hit Closest(const glm::vec3& origin, const glm::vec3& direction, uint32_t skip, float maxT = INF) const {
|
|
Hit hit;
|
|
hit.t = maxT;
|
|
if (m_Nodes.empty()) return hit;
|
|
const auto inverse = Inverse(direction);
|
|
uint32_t stack[128];
|
|
int top = 0;
|
|
uint32_t index = 0;
|
|
while (true) {
|
|
const auto& node = m_Nodes[index];
|
|
if (node.count > 0) {
|
|
for (uint32_t i = node.first; i < node.first + node.count; i++) Intersect(m_Triangles[i], origin, direction, skip, hit);
|
|
} else {
|
|
const uint32_t left = node.first, right = node.first + 1;
|
|
const float tl = Enter(m_Nodes[left], origin, inverse, hit.t);
|
|
const float tr = Enter(m_Nodes[right], origin, inverse, hit.t);
|
|
if (tl <= tr) {
|
|
if (tr != INF && top < 128) stack[top++] = right;
|
|
if (tl != INF) { index = left; continue; }
|
|
} else {
|
|
if (tl != INF && top < 128) stack[top++] = left;
|
|
index = right;
|
|
continue;
|
|
}
|
|
}
|
|
// Next from the stack, skipping nodes now farther than the nearest hit
|
|
bool found = false;
|
|
while (top > 0) {
|
|
index = stack[--top];
|
|
if (Enter(m_Nodes[index], origin, inverse, hit.t) != INF) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) break;
|
|
}
|
|
return hit;
|
|
}
|
|
|
|
private:
|
|
struct Node {
|
|
glm::vec3 min{ INF };
|
|
uint32_t first{}; // leaf: first triangle; inner: the left child (the right one follows it)
|
|
glm::vec3 max{ -INF };
|
|
uint32_t count{}; // triangles, 0 for inner nodes
|
|
};
|
|
|
|
// Where the ray enters the node's box, INF when it misses it before `maxT`
|
|
static float Enter(const Node& node, const glm::vec3& origin, const glm::vec3& inverse, float maxT) {
|
|
const auto t0 = (node.min - origin) * inverse;
|
|
const auto t1 = (node.max - origin) * inverse;
|
|
const auto near = glm::min(t0, t1), far = glm::max(t0, t1);
|
|
const float enter = std::max(std::max(near.x, near.y), std::max(near.z, 0.0f));
|
|
const float exit = std::min(std::min(far.x, far.y), std::min(far.z, maxT));
|
|
return enter <= exit ? enter : INF;
|
|
}
|
|
|
|
struct Triangle {
|
|
glm::vec3 a, e1, e2;
|
|
uint32_t index;
|
|
};
|
|
|
|
static glm::vec3 Inverse(const glm::vec3& d) {
|
|
const auto safe = [](float x) { return 1.0f / (std::abs(x) > 1e-20f ? x : std::copysign(1e-20f, x)); };
|
|
return { safe(d.x), safe(d.y), safe(d.z) };
|
|
}
|
|
|
|
// Möller-Trumbore; keeps the hit when it's nearer than hit.t
|
|
static bool Intersect(const Triangle& tri, const glm::vec3& origin, const glm::vec3& direction, uint32_t skip, Hit& hit) {
|
|
if (tri.index == skip) return false;
|
|
const auto p = glm::cross(direction, tri.e2);
|
|
const float det = glm::dot(tri.e1, p);
|
|
if (det == 0.0f) return false;
|
|
const float inv = 1.0f / det;
|
|
const auto s = origin - tri.a;
|
|
const float u = glm::dot(s, p) * inv;
|
|
if (u < 0.0f || u > 1.0f) return false;
|
|
const auto q = glm::cross(s, tri.e1);
|
|
const float v = glm::dot(direction, q) * inv;
|
|
if (v < 0.0f || u + v > 1.0f) return false;
|
|
const float t = glm::dot(tri.e2, q) * inv;
|
|
if (!(t > 0.0f) || t >= hit.t) return false;
|
|
hit.t = t;
|
|
hit.triangle = tri.index;
|
|
hit.u = u;
|
|
hit.v = v;
|
|
return true;
|
|
}
|
|
|
|
void Build(std::vector<uint32_t>& order, const std::vector<glm::vec3>& lo, const std::vector<glm::vec3>& hi, const std::vector<glm::vec3>& centre) {
|
|
constexpr int BINS = 16;
|
|
constexpr uint32_t LEAF = 4;
|
|
struct Task { uint32_t node, first, count; };
|
|
const auto area = [](const glm::vec3& min, const glm::vec3& max) {
|
|
const auto d = glm::max(max - min, glm::vec3(0.0f));
|
|
return d.x * d.y + d.y * d.z + d.z * d.x;
|
|
};
|
|
m_Nodes.reserve(order.size() * 2 / LEAF + 1);
|
|
m_Nodes.push_back({});
|
|
std::vector<Task> tasks{ { 0, 0, static_cast<uint32_t>(order.size()) } };
|
|
while (!tasks.empty()) {
|
|
const auto task = tasks.back();
|
|
tasks.pop_back();
|
|
Node node;
|
|
glm::vec3 cmin(INF), cmax(-INF);
|
|
for (uint32_t i = task.first; i < task.first + task.count; i++) {
|
|
node.min = glm::min(node.min, lo[order[i]]);
|
|
node.max = glm::max(node.max, hi[order[i]]);
|
|
cmin = glm::min(cmin, centre[order[i]]);
|
|
cmax = glm::max(cmax, centre[order[i]]);
|
|
}
|
|
node.first = task.first;
|
|
node.count = task.count;
|
|
int bestAxis = -1;
|
|
int bestSplit = 0;
|
|
float bestCost = static_cast<float>(task.count) * area(node.min, node.max); // not splitting
|
|
if (task.count > LEAF) {
|
|
for (int axis = 0; axis < 3; axis++) {
|
|
const float extent = cmax[axis] - cmin[axis];
|
|
if (!(extent > 0.0f)) continue;
|
|
struct Bin { glm::vec3 min{ INF }, max{ -INF }; uint32_t count{}; };
|
|
std::array<Bin, BINS> bins{};
|
|
const float scale = BINS / extent;
|
|
for (uint32_t i = task.first; i < task.first + task.count; i++) {
|
|
const auto t = order[i];
|
|
const int b = std::min(BINS - 1, static_cast<int>((centre[t][axis] - cmin[axis]) * scale));
|
|
bins[b].min = glm::min(bins[b].min, lo[t]);
|
|
bins[b].max = glm::max(bins[b].max, hi[t]);
|
|
bins[b].count++;
|
|
}
|
|
std::array<float, BINS - 1> leftCost{};
|
|
glm::vec3 lmin(INF), lmax(-INF);
|
|
uint32_t lcount = 0;
|
|
for (int b = 0; b < BINS - 1; b++) {
|
|
lmin = glm::min(lmin, bins[b].min);
|
|
lmax = glm::max(lmax, bins[b].max);
|
|
lcount += bins[b].count;
|
|
leftCost[b] = lcount ? lcount * area(lmin, lmax) : 0.0f;
|
|
}
|
|
glm::vec3 rmin(INF), rmax(-INF);
|
|
uint32_t rcount = 0;
|
|
for (int b = BINS - 1; b > 0; b--) {
|
|
rmin = glm::min(rmin, bins[b].min);
|
|
rmax = glm::max(rmax, bins[b].max);
|
|
rcount += bins[b].count;
|
|
const float cost = leftCost[b - 1] + (rcount ? rcount * area(rmin, rmax) : 0.0f);
|
|
if (rcount > 0 && rcount < task.count && cost < bestCost) {
|
|
bestCost = cost;
|
|
bestAxis = axis;
|
|
bestSplit = b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (bestAxis < 0) {
|
|
m_Nodes[task.node] = node;
|
|
continue;
|
|
}
|
|
const float extent = cmax[bestAxis] - cmin[bestAxis];
|
|
const float scale = BINS / extent;
|
|
auto* begin = order.data() + task.first;
|
|
auto* middle = std::partition(begin, begin + task.count, [&](uint32_t t) {
|
|
return std::min(BINS - 1, static_cast<int>((centre[t][bestAxis] - cmin[bestAxis]) * scale)) < bestSplit;
|
|
});
|
|
const auto leftCount = static_cast<uint32_t>(middle - begin);
|
|
node.first = static_cast<uint32_t>(m_Nodes.size());
|
|
node.count = 0;
|
|
m_Nodes[task.node] = node;
|
|
m_Nodes.push_back({});
|
|
m_Nodes.push_back({});
|
|
tasks.push_back({ node.first, task.first, leftCount });
|
|
tasks.push_back({ node.first + 1, task.first + leftCount, task.count - leftCount });
|
|
}
|
|
}
|
|
|
|
std::vector<Node> m_Nodes;
|
|
std::vector<Triangle> m_Triangles;
|
|
};
|
|
|
|
// LU Toolbox's ground plane: a box 1000 x 1000 x 100 whose top is at LDD y 0, black (a path hitting it ends)
|
|
float GroundHit(const glm::vec3& origin, const glm::vec3& direction, float maxT) {
|
|
static const glm::vec3 MIN(-500.0f, -100.0f, -500.0f), MAX(500.0f, 0.0f, 500.0f);
|
|
float enter = 0.0f, exit = maxT;
|
|
for (int axis = 0; axis < 3; axis++) {
|
|
if (std::abs(direction[axis]) < 1e-20f) {
|
|
if (origin[axis] < MIN[axis] || origin[axis] > MAX[axis]) return INF;
|
|
continue;
|
|
}
|
|
const float inv = 1.0f / direction[axis];
|
|
float t0 = (MIN[axis] - origin[axis]) * inv, t1 = (MAX[axis] - origin[axis]) * inv;
|
|
if (t0 > t1) std::swap(t0, t1);
|
|
enter = std::max(enter, t0);
|
|
exit = std::min(exit, t1);
|
|
if (enter > exit) return INF;
|
|
}
|
|
return enter;
|
|
}
|
|
|
|
class Tracer {
|
|
public:
|
|
Tracer(const UgcModel::Mesh& mesh, const UgcHsr::Options& options) : m_Mesh(mesh), m_Bvh(mesh), m_Options(options) {
|
|
m_Smooth = mesh.normals.size() == mesh.positions.size();
|
|
}
|
|
|
|
// The triangle's normal from its winding (unit; zero when it has no area)
|
|
glm::vec3 FaceNormal(uint32_t t) const {
|
|
const auto& a = m_Mesh.positions[m_Mesh.indices[t * 3]];
|
|
const auto n = glm::cross(m_Mesh.positions[m_Mesh.indices[t * 3 + 1]] - a, m_Mesh.positions[m_Mesh.indices[t * 3 + 2]] - a);
|
|
const float length = glm::length(n);
|
|
return length > 0.0f ? n / length : glm::vec3(0.0f);
|
|
}
|
|
|
|
// The vertex normals at barycentric w (Cycles' smooth normal: the face's own when they sum to nothing)
|
|
glm::vec3 ShadingNormal(uint32_t t, const glm::vec3& w, const glm::vec3& faceNormal) const {
|
|
if (!m_Smooth) return faceNormal;
|
|
const auto n = m_Mesh.normals[m_Mesh.indices[t * 3]] * w.x + m_Mesh.normals[m_Mesh.indices[t * 3 + 1]] * w.y + m_Mesh.normals[m_Mesh.indices[t * 3 + 2]] * w.z;
|
|
const float length = glm::length(n);
|
|
return length > 0.0f ? n / length : faceNormal;
|
|
}
|
|
|
|
glm::vec3 Position(uint32_t t, const glm::vec3& w) const {
|
|
return m_Mesh.positions[m_Mesh.indices[t * 3]] * w.x + m_Mesh.positions[m_Mesh.indices[t * 3 + 1]] * w.y + m_Mesh.positions[m_Mesh.indices[t * 3 + 2]] * w.z;
|
|
}
|
|
|
|
/**
|
|
* One path from point w (barycentric) of triangle t, as a Cycles diffuse bake traces it: whether it reaches the
|
|
* sky. The path bounces off the model in the directions the bake material draws until a bounce ray hits
|
|
* nothing, which is the sky. The sky isn't sampled directly: Cycles doesn't sample a world of one flat color as
|
|
* a light, so only rays that happen to leave count. Up to `bounces` bounces (4 of them glossy), and from the
|
|
* second bounce on the path may end early (Cycles' Russian roulette: it goes on with probability
|
|
* sqrt(throughput)).
|
|
*/
|
|
bool Escapes(uint32_t t, const glm::vec3& w, Random& random) const {
|
|
glm::vec3 ng = FaceNormal(t);
|
|
// The bake looks at the point along its smooth normal (the ray comes from there): that side is lit, and
|
|
// when the winding faces the other way Cycles treats it as the back of the face (both normals turned)
|
|
glm::vec3 n = ShadingNormal(t, w, ng);
|
|
glm::vec3 incoming = n;
|
|
if (glm::dot(ng, incoming) < 0.0f) {
|
|
ng = -ng;
|
|
n = -n;
|
|
}
|
|
glm::vec3 p = Position(t, w);
|
|
uint32_t self = t;
|
|
float throughput = 1.0f;
|
|
float minRayPdf = INF;
|
|
int glossy = 0;
|
|
for (int bounce = 0;; bounce++) {
|
|
// The material's normal: the Principled BSDF keeps its mirror reflection above the surface
|
|
const Principled material(EnsureValidReflection(ng, incoming, n), incoming, ng, n, bounce == 0, minRayPdf);
|
|
const auto sample = material.Draw(random);
|
|
// Nothing sampled (below the surface): the path ends
|
|
if (!(sample.pdf > 0.0f) || !(sample.throughput > 0.0f)) return false;
|
|
const auto& direction = sample.direction;
|
|
throughput *= sample.throughput;
|
|
minRayPdf = std::min(minRayPdf, sample.pdf);
|
|
const auto hit = m_Bvh.Closest(p, direction, self);
|
|
if (m_Options.groundPlane && GroundHit(p, direction, hit.t) < hit.t) return false;
|
|
if (hit.triangle == UINT32_MAX) return true;
|
|
// Past the bounce limits the next surface doesn't scatter (Cycles: Max Bounces, Glossy 4)
|
|
if (bounce + 1 > m_Options.bounces) return false;
|
|
if (sample.glossy && ++glossy > GLOSSY_BOUNCES) return false;
|
|
if (bounce + 1 >= 2) {
|
|
const float probability = std::min(std::sqrt(throughput), 1.0f);
|
|
if (random.Float() >= probability) return false;
|
|
throughput /= probability;
|
|
}
|
|
self = hit.triangle;
|
|
ng = FaceNormal(self);
|
|
n = ShadingNormal(self, glm::vec3(1.0f - hit.u - hit.v, hit.u, hit.v), ng);
|
|
incoming = -direction;
|
|
// Hit from behind: the back is lit (both normals turned towards the ray)
|
|
if (glm::dot(ng, incoming) < 0.0f) {
|
|
ng = -ng;
|
|
n = -n;
|
|
}
|
|
p = p + direction * hit.t;
|
|
}
|
|
}
|
|
|
|
private:
|
|
const UgcModel::Mesh& m_Mesh;
|
|
Bvh m_Bvh;
|
|
const UgcHsr::Options& m_Options;
|
|
bool m_Smooth{};
|
|
};
|
|
}
|
|
|
|
namespace UgcHsr {
|
|
std::vector<glm::vec3> SamplePoints(const glm::vec3& a, const glm::vec3& b, const glm::vec3& c, float spacing, size_t minimum) {
|
|
// Too small to lay out: the centre and one point towards each corner (the centres of its four halved-side
|
|
// triangles)
|
|
const std::vector<glm::vec3> fallback{ { 1.0f / 3, 1.0f / 3, 1.0f / 3 }, { 2.0f / 3, 1.0f / 6, 1.0f / 6 }, { 1.0f / 6, 2.0f / 3, 1.0f / 6 },
|
|
{ 1.0f / 6, 1.0f / 6, 2.0f / 3 } };
|
|
const std::array<glm::vec3, 3> corners{ a, b, c };
|
|
// The longest side from corner `first` to the next; the third is the apex
|
|
int first = 0;
|
|
float longest = -1.0f;
|
|
for (int i = 0; i < 3; i++) {
|
|
const float length = glm::length(corners[(i + 1) % 3] - corners[i]);
|
|
if (length > longest) {
|
|
longest = length;
|
|
first = i;
|
|
}
|
|
}
|
|
const float area = 0.5f * glm::length(glm::cross(b - a, c - a));
|
|
if (!(longest > 0.0f) || !(area > 0.0f) || !(spacing > 0.0f) || !std::isfinite(area)) return fallback;
|
|
minimum = std::min(minimum, MAX_POINTS);
|
|
// Very big triangles: points further apart, at most MAX_POINTS
|
|
spacing = std::max(spacing, std::sqrt(area / static_cast<float>(MAX_POINTS)));
|
|
const float height = 2.0f * area / longest;
|
|
std::vector<glm::vec3> points;
|
|
for (int attempt = 0; attempt < 16; attempt++) {
|
|
points.clear();
|
|
const int along = std::max(1, static_cast<int>(std::ceil(longest / spacing)));
|
|
const int rows = std::max(1, static_cast<int>(std::ceil(height / spacing)));
|
|
for (int row = 0; row < rows; row++) {
|
|
// v: from the longest side (0) to the apex (1); the row is (1 - v) of the side's length
|
|
const float v = (row + 0.5f) / rows;
|
|
const int count = std::max(1, static_cast<int>(std::lround(along * (1.0f - v))));
|
|
for (int j = 0; j < count; j++) {
|
|
const float u = (j + 0.5f) / count;
|
|
glm::vec3 w{};
|
|
w[first] = (1.0f - u) * (1.0f - v);
|
|
w[(first + 1) % 3] = u * (1.0f - v);
|
|
w[(first + 2) % 3] = v;
|
|
points.push_back(w);
|
|
}
|
|
}
|
|
if (points.size() >= minimum) break;
|
|
// Fewer than the minimum: closer together
|
|
spacing *= 0.95f * std::sqrt(static_cast<float>(points.size()) / static_cast<float>(minimum));
|
|
}
|
|
return points.size() < fallback.size() ? fallback : points;
|
|
}
|
|
|
|
std::vector<bool> Visible(const UgcModel::Mesh& mesh, const Options& options, uint64_t* pointCount, uint64_t* pathCount) {
|
|
const size_t triangles = mesh.TriangleCount();
|
|
std::vector<bool> visible(triangles, true);
|
|
if (triangles == 0) return visible;
|
|
const Tracer tracer(mesh, options);
|
|
const int samples = std::max(options.samples, 1);
|
|
uint64_t points = 0, paths = 0, sinceCheckpoint = 0;
|
|
for (uint32_t t = 0; t < triangles; t++) {
|
|
const auto& a = mesh.positions[mesh.indices[t * 3]];
|
|
const auto& b = mesh.positions[mesh.indices[t * 3 + 1]];
|
|
const auto& c = mesh.positions[mesh.indices[t * 3 + 2]];
|
|
// A triangle without area draws nothing (LU Toolbox's bake leaves it dark too): removed
|
|
if (tracer.FaceNormal(t) == glm::vec3(0.0f)) {
|
|
visible[t] = false;
|
|
continue;
|
|
}
|
|
const auto weights = SamplePoints(a, b, c, options.spacing, static_cast<size_t>(std::max(options.minPoints, 1)));
|
|
points += weights.size();
|
|
bool escaped = false;
|
|
// A path from each point, then another from each, ...: a triangle that's seen is usually known at once
|
|
for (int sample = 0; sample < samples && !escaped; sample++) {
|
|
for (size_t i = 0; i < weights.size(); i++) {
|
|
Random random(PathSeed(options.seed, t, i, static_cast<uint64_t>(sample)));
|
|
paths++;
|
|
if (tracer.Escapes(t, weights[i], random)) {
|
|
escaped = true;
|
|
break;
|
|
}
|
|
}
|
|
sinceCheckpoint += weights.size();
|
|
if (sinceCheckpoint >= 256) {
|
|
UgcThrottle::Checkpoint();
|
|
sinceCheckpoint = 0;
|
|
}
|
|
}
|
|
visible[t] = escaped;
|
|
}
|
|
if (pointCount) *pointCount = points;
|
|
if (pathCount) *pathCount = paths;
|
|
return visible;
|
|
}
|
|
|
|
Result RemoveHiddenFaces(UgcModel::Model& model, const Options& options) {
|
|
Result result;
|
|
auto& opaque = model.opaque;
|
|
result.trianglesBefore = opaque.TriangleCount() + model.transparent.TriangleCount();
|
|
if (opaque.Empty() || !options.enabled) return result;
|
|
result.kept = Visible(opaque, options, &result.points, &result.paths);
|
|
for (const bool kept : result.kept) result.trianglesRemoved += kept ? 0 : 1;
|
|
UgcModel::KeepTriangles(opaque, result.kept);
|
|
return result;
|
|
}
|
|
}
|