GroomInstance.cpp

浏览该文件的文档.

#include "graphics/hair/GroomInstance.h"
 
#include "common/Diagnostic.h"
#include "common/Exception.h"
#include "graphics/Color.h"
#include "graphics/Graphics.h"
#include "graphics/HairCards.h"
#include "graphics/HairShader.h"
#include "graphics/Mesh.h"
#include "graphics/Shader.h"
#include "graphics/Texture.h"
#include "graphics/hair/RibbonBuilder.h"
 
#include <algorithm>
#include <cmath>
#include <vector>
 
namespace eve::graphics::hair {
namespace {
 
CardMeshData buildCardsFromStrands(const StrandsDatas &strands, float widthScale) {
    CardMeshData combined;
    const float width = std::max(1e-4f, 0.004f * widthScale);
    std::vector<float> pointsXYZ;
    for (size_t ci = 0; ci < strands.curveCount(); ++ci) {
        const auto pts = strands.curvePoints(ci);
        if (pts.size() < 2) continue;
        pointsXYZ.clear();
        pointsXYZ.reserve(pts.size() * 3);
        float avgRadius = 0.f;
        for (const StrandPoint &p : pts) {
            pointsXYZ.push_back(p.position.x);
            pointsXYZ.push_back(p.position.y);
            pointsXYZ.push_back(p.position.z);
            avgRadius += p.radius;
        }
        avgRadius /= float(pts.size());
        const float cardWidth = std::max(width, avgRadius * 4.f * widthScale);
        appendCardMesh(combined, buildCardsAlongPolyline(pointsXYZ.data(), int(pts.size()), cardWidth));
    }
    return combined;
}
 
}  // namespace
 
GroomInstance::GroomInstance(Graphics *gfx) : gfx_(gfx) {
    if (!gfx_) throw eve::Exception("GroomInstance: null graphics");
}
 
GroomInstance::~GroomInstance() = default;
 
const GroomGroup *GroomInstance::primaryGroup() const { return asset_.groupAt(0); }
 
size_t GroomInstance::resolveLodIndex(const GroomGroup &group) const {
    if (group.lods.empty()) return 0;
    if (forcedLod_ >= 0) {
        size_t lodIndex = size_t(forcedLod_);
        if (lodIndex >= group.lods.size()) lodIndex = group.lods.size() - 1;
        return lodIndex;
    }
    return selectLodIndex(group.lods, screenSize_);
}
 
StrandsDatas GroomInstance::decimatedStrands(const StrandsDatas &src, float curveFraction) const {
    StrandsDatas out;
    if (src.curveCount() == 0) return out;
    const float frac = std::clamp(curveFraction, 0.05f, 1.f);
    const size_t keep =
        std::max<size_t>(1, size_t(std::ceil(double(src.curveCount()) * double(frac))));
    const size_t step = std::max<size_t>(1, src.curveCount() / keep);
 
    std::vector<StrandPoint> points;
    std::vector<StrandCurve> curves;
    points.reserve(src.pointCount());
    curves.reserve(keep);
 
    for (size_t ci = 0; ci < src.curveCount(); ci += step) {
        if (curves.size() >= keep) break;
        const auto pts = src.curvePoints(ci);
        if (pts.size() < 2) continue;
        StrandCurve curve;
        curve.pointOffset = uint32_t(points.size());
        curve.pointCount = uint32_t(pts.size());
        float len = 0.f;
        for (size_t pi = 0; pi < pts.size(); ++pi) {
            points.push_back(pts[pi]);
            if (pi > 0) len += glm::length(pts[pi].position - pts[pi - 1].position);
        }
        curve.length = len;
        curves.push_back(curve);
    }
    out.setPoints(std::move(points));
    out.setCurves(std::move(curves));
    return out;
}
 
Result<void> GroomInstance::rebuildClusterGrids() {
    groupCull_.assign(asset_.groupCount(), GroupCullState{});
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *group = asset_.groupAt(gi);
        if (!group) continue;
        auto built = groupCull_[gi].clusters.build(group->strands, clusterCellSize_);
        if (!built.ok()) return Result<void>::failure(built.status());
    }
    return Result<void>::success();
}
 
Result<void> GroomInstance::bakeFromStrands(StrandsDatas strands, const char *debugName) {
    auto ok = strands.validate();
    if (!ok.ok()) return Result<void>::failure(ok.status());
 
    GroomGroup group;
    group.name = debugName ? debugName : "default";
    group.groupId = 0;
    group.strands = std::move(strands);
 
    // Mid LOD uses HairCards geometry (PR #400); far culls to None.
    GroomLod nearLod;
    nearLod.screenSize = 1.f;
    nearLod.representation = Representation::Strands;
    nearLod.curveFraction = 1.f;
    GroomLod midLod;
    midLod.screenSize = 0.35f;
    midLod.representation = Representation::Cards;
    midLod.curveFraction = 0.3f;
    midLod.thicknessScale = 2.f;
    GroomLod farLod;
    farLod.screenSize = 0.12f;
    farLod.representation = Representation::None;
    farLod.curveFraction = 0.05f;
    group.lods = {nearLod, midLod, farLod};
 
    GroomAsset asset;
    auto add = asset.addGroup(std::move(group));
    if (!add.ok()) return Result<void>::failure(add.status());
    return setAsset(asset);
}
 
Result<void> GroomInstance::setAsset(const GroomAsset &asset) {
    auto ok = asset.validate();
    if (!ok.ok()) return Result<void>::failure(ok.status());
    asset_ = asset;
    const bool keepSim = guideSimEnabled_;
    clearGuideSimulation();
    auto grid = rebuildClusterGrids();
    if (!grid.ok()) return Result<void>::failure(grid.status());
    auto rebuilt = rebuild();
    if (!rebuilt.ok()) return Result<void>::failure(rebuilt.status());
    if (keepSim) {
        return enableGuideSimulation(guideSimParams_, guideFraction_, guideInterpMode_);
    }
    return Result<void>::success();
}
 
Result<void> GroomInstance::bakeProceduralPlane(float sizeX, float sizeZ,
                                                const ProceduralParams &params) {
    auto strands = generateOnPlane(sizeX, sizeZ, params);
    if (!strands.ok()) return Result<void>::failure(strands.status());
    return bakeFromStrands(std::move(strands).value(), "procedural_plane");
}
 
Result<void> GroomInstance::bakeProceduralMesh(const float *posXYZ, const float *nrmXYZ,
                                               int vertexCount, const uint32_t *indices,
                                               int indexCount, const ProceduralParams &params) {
    auto strands = generateOnMesh(posXYZ, nrmXYZ, vertexCount, indices, indexCount, params);
    if (!strands.ok()) return Result<void>::failure(strands.status());
    return bakeFromStrands(std::move(strands).value(), "procedural_mesh");
}
 
void GroomInstance::setForcedLod(int lod) { forcedLod_ = lod; }
 
int GroomInstance::getForcedLod() const { return forcedLod_; }
 
void GroomInstance::setScreenSize(float screenSize) {
    screenSize_ = std::clamp(screenSize, 0.f, 1.f);
}
 
float GroomInstance::getScreenSize() const { return screenSize_; }
 
void GroomInstance::setWidthScale(float scale) { widthScale_ = scale > 1e-6f ? scale : 1e-6f; }
 
float GroomInstance::getWidthScale() const { return widthScale_; }
 
void GroomInstance::setSideHint(float x, float y, float z) { sideHint_ = glm::vec3(x, y, z); }
 
void GroomInstance::setClusterCullingEnabled(bool enabled) { clusterCulling_ = enabled; }
 
bool GroomInstance::isClusterCullingEnabled() const { return clusterCulling_; }
 
void GroomInstance::setMarschnerLobes(float r, float tt, float trt) {
    marschnerR_ = r >= 0.f ? r : 0.f;
    marschnerTT_ = tt >= 0.f ? tt : 0.f;
    marschnerTRT_ = trt >= 0.f ? trt : 0.f;
    applyShadingParams();
}
 
float GroomInstance::getMarschnerR() const { return marschnerR_; }
 
float GroomInstance::getMarschnerTT() const { return marschnerTT_; }
 
float GroomInstance::getMarschnerTRT() const { return marschnerTRT_; }
 
void GroomInstance::setSelfShadow(float strength, float bias, float rootAo) {
    selfShadowStrength_ = std::clamp(strength, 0.f, 1.f);
    selfShadowBias_ = std::clamp(bias, 0.f, 1.f);
    rootAoStrength_ = std::clamp(rootAo, 0.f, 1.f);
    applyShadingParams();
}
 
float GroomInstance::getSelfShadowStrength() const { return selfShadowStrength_; }
 
float GroomInstance::getSelfShadowBias() const { return selfShadowBias_; }
 
float GroomInstance::getRootAoStrength() const { return rootAoStrength_; }
 
void GroomInstance::clearGuideSimulation() {
    groupSim_.clear();
    guideSimEnabled_ = false;
}
 
Result<void> GroomInstance::setupGuideSimulation(float guideFraction, InterpolationMode mode) {
    groupSim_.assign(asset_.groupCount(), GroupSimState{});
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *group = asset_.groupAt(gi);
        if (!group) continue;
        GroupSimState &state = groupSim_[gi];
        state.restStrands = group->strands;
 
        if (group->guides.curveCount() > 0) {
            state.restGuides = group->guides;
        } else {
            auto guides = extractGuides(group->strands, guideFraction);
            if (!guides.ok()) return Result<void>::failure(guides.status());
            state.restGuides = std::move(guides).value();
        }
 
        auto weights = buildGuideWeights(state.restStrands, state.restGuides, 3, mode);
        if (!weights.ok()) return Result<void>::failure(weights.status());
        state.weights = std::move(weights).value();
 
        auto reset = state.simulator.reset(state.restGuides, guideSimParams_);
        if (!reset.ok()) return Result<void>::failure(reset.status());
 
        state.deformedStrands = state.restStrands;
        state.active = true;
    }
    guideFraction_ = std::clamp(guideFraction, 0.01f, 1.f);
    guideInterpMode_ = mode;
    guideSimEnabled_ = true;
    return Result<void>::success();
}
 
Result<void> GroomInstance::enableGuideSimulation(const GuideSimParams &params, float guideFraction,
                                                  InterpolationMode mode) {
    if (asset_.groupCount() == 0) {
        return Result<void>::failure(Diagnostic::error(
            DiagnosticCode::InvalidArgument, "GroomInstance::enableGuideSimulation: no groups",
            "hair.groom.sim"));
    }
    guideSimParams_ = params;
    auto setup = setupGuideSimulation(guideFraction, mode);
    if (!setup.ok()) {
        clearGuideSimulation();
        return Result<void>::failure(setup.status());
    }
    return rebuild();
}
 
Result<void> GroomInstance::disableGuideSimulation() {
    clearGuideSimulation();
    if (asset_.groupCount() == 0) return Result<void>::success();
    return rebuild();
}
 
bool GroomInstance::isGuideSimulationEnabled() const { return guideSimEnabled_; }
 
void GroomInstance::setGuideSimParams(const GuideSimParams &params) {
    guideSimParams_ = params;
    for (GroupSimState &state : groupSim_) {
        if (state.active) state.simulator.setParams(guideSimParams_);
    }
}
 
const GuideSimParams &GroomInstance::getGuideSimParams() const { return guideSimParams_; }
 
Result<void> GroomInstance::update(float dt) {
    if (!guideSimEnabled_) return Result<void>::success();
    if (groupSim_.size() != asset_.groupCount()) {
        auto setup = setupGuideSimulation(guideFraction_, guideInterpMode_);
        if (!setup.ok()) return Result<void>::failure(setup.status());
    }
 
    for (size_t gi = 0; gi < groupSim_.size(); ++gi) {
        GroupSimState &state = groupSim_[gi];
        if (!state.active) continue;
        auto stepped = state.simulator.step(dt);
        if (!stepped.ok()) return Result<void>::failure(stepped.status());
        auto deformedGuides = state.simulator.snapshot();
        if (!deformedGuides.ok()) return Result<void>::failure(deformedGuides.status());
        auto strands = interpolateStrands(state.restStrands, state.restGuides,
                                          deformedGuides.value(), state.weights, guideInterpMode_);
        if (!strands.ok()) return Result<void>::failure(strands.status());
        state.deformedStrands = std::move(strands).value();
    }
    return rebuild();
}
 
Mesh *GroomInstance::getMesh() const { return mesh_; }
 
Shader *GroomInstance::getShader() const { return shader_; }
 
Texture *GroomInstance::getTexture() const { return texture_; }
 
size_t GroomInstance::getGroupCount() const { return asset_.groupCount(); }
 
int GroomInstance::getActiveLodIndex() const { return activeLodIndex_; }
 
int GroomInstance::getActiveRepresentation() const { return int(activeRepresentation_); }
 
size_t GroomInstance::getClusterCount() const {
    size_t total = 0;
    for (const GroupCullState &state : groupCull_) total += state.clusters.clusterCount();
    return total;
}
 
int GroomInstance::getVisibleCurveCount() const {
    if (clusterCulling_) {
        int total = 0;
        bool anyMask = false;
        for (const GroupCullState &state : groupCull_) {
            if (!state.hasVisibility) continue;
            anyMask = true;
            total += int(state.visibleCurves.size());
        }
        if (anyMask) return total;
    }
    int total = 0;
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *g = asset_.groupAt(gi);
        if (g) total += int(g->strands.curveCount());
    }
    return total;
}
 
void GroomInstance::applyShadingParams() {
    if (!shader_) return;
    shader_->sendFloat("marschnerR", marschnerR_);
    shader_->sendFloat("marschnerTT", marschnerTT_);
    shader_->sendFloat("marschnerTRT", marschnerTRT_);
    shader_->sendFloat("selfShadowStrength", selfShadowStrength_);
    shader_->sendFloat("selfShadowBias", selfShadowBias_);
    shader_->sendFloat("rootAoStrength", rootAoStrength_);
}
 
Result<void> GroomInstance::ensureDrawResources() {
    if (!shader_) {
        shader_ = createShader(gfx_);
        if (!shader_) {
            return Result<void>::failure(Diagnostic::error(
                DiagnosticCode::Failed, "GroomInstance: hair shader failed", "hair.groom.shader"));
        }
    }
    applyShadingParams();
    if (!texture_) {
        const uint8_t white[4] = {210, 170, 120, 255};
        texture_ = gfx_->newTexture(1, 1, white);
        if (!texture_) {
            return Result<void>::failure(Diagnostic::error(
                DiagnosticCode::Failed, "GroomInstance: texture failed", "hair.groom.texture"));
        }
    }
    return Result<void>::success();
}
 
Result<void> GroomInstance::updateVisibility(const float *viewProj16) {
    if (!viewProj16) {
        return Result<void>::failure(Diagnostic::error(
            DiagnosticCode::InvalidArgument, "GroomInstance::updateVisibility: null viewProj",
            "hair.groom.viewProj"));
    }
    if (groupCull_.size() != asset_.groupCount()) {
        auto grid = rebuildClusterGrids();
        if (!grid.ok()) return Result<void>::failure(grid.status());
    }
    for (GroupCullState &state : groupCull_) {
        auto visibleClusters = state.clusters.cullClusters(viewProj16);
        if (!visibleClusters.ok()) return Result<void>::failure(visibleClusters.status());
        auto curves = state.clusters.collectCurveIndices(visibleClusters.value());
        if (!curves.ok()) return Result<void>::failure(curves.status());
        state.visibleCurves = std::move(curves).value();
        state.hasVisibility = true;
    }
    return rebuild();
}
 
Result<void> GroomInstance::rebuild() {
    if (asset_.groupCount() == 0) {
        return Result<void>::failure(Diagnostic::error(
            DiagnosticCode::InvalidArgument, "GroomInstance::rebuild: no groups", "hair.groom"));
    }
    if (groupCull_.size() != asset_.groupCount()) {
        auto grid = rebuildClusterGrids();
        if (!grid.ok()) return Result<void>::failure(grid.status());
    }
 
    // Report LOD from the primary group (representative for script getters).
    const GroomGroup *primary = primaryGroup();
    if (primary && !primary->lods.empty()) {
        activeLodIndex_ = int(resolveLodIndex(*primary));
        activeRepresentation_ = primary->lods[size_t(activeLodIndex_)].representation;
    } else {
        activeLodIndex_ = 0;
        activeRepresentation_ = Representation::None;
    }
 
    RibbonMesh ribbonCombined;
    CardMeshData cardCombined;
    bool anyRibbon = false;
    bool anyCards = false;
 
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *group = asset_.groupAt(gi);
        if (!group || group->lods.empty()) continue;
 
        const size_t lodIndex = resolveLodIndex(*group);
        const GroomLod &lod = group->lods[lodIndex];
        if (lod.representation == Representation::None) continue;
        if (lod.representation == Representation::Meshes) {
            mesh_ = nullptr;
            return Result<void>::failure(Diagnostic::error(
                DiagnosticCode::Unsupported,
                "GroomInstance::rebuild: Meshes LOD not implemented yet",
                "hair.groom.representation"));
        }
 
        StrandsDatas source = group->strands;
        if (guideSimEnabled_ && gi < groupSim_.size() && groupSim_[gi].active) {
            source = groupSim_[gi].deformedStrands;
        }
        if (clusterCulling_ && gi < groupCull_.size() && groupCull_[gi].hasVisibility) {
            if (groupCull_[gi].visibleCurves.empty()) continue;
            auto filtered = filterStrandsByCurves(source, groupCull_[gi].visibleCurves);
            if (!filtered.ok()) return Result<void>::failure(filtered.status());
            source = std::move(filtered).value();
        }
 
        StrandsDatas strands = decimatedStrands(source, lod.curveFraction);
        auto ok = strands.validate();
        if (!ok.ok()) return Result<void>::failure(ok.status());
 
        if (lod.representation == Representation::Cards) {
            appendCardMesh(cardCombined,
                           buildCardsFromStrands(strands, widthScale_ * lod.thicknessScale));
            anyCards = true;
            continue;
        }
 
        RibbonParams ribbon;
        ribbon.sideHint = sideHint_;
        ribbon.widthScale = widthScale_ * lod.thicknessScale;
        auto meshData = buildRibbons(strands, ribbon);
        if (!meshData.ok()) return Result<void>::failure(meshData.status());
        appendRibbonMesh(ribbonCombined, meshData.value());
        anyRibbon = true;
    }
 
    // Prefer the primary group's representation when both ribbon and cards exist.
    const bool useCards =
        anyCards && (!anyRibbon || activeRepresentation_ == Representation::Cards);
 
    if (useCards) {
        if (cardCombined.indices.empty()) {
            mesh_ = nullptr;
            return Result<void>::success();
        }
        mesh_ = uploadCardMesh(gfx_, cardCombined);
        if (!mesh_) {
            return Result<void>::failure(Diagnostic::error(
                DiagnosticCode::Failed, "GroomInstance::rebuild: card mesh upload failed",
                "hair.groom.cards"));
        }
        return ensureDrawResources();
    }
 
    if (!anyRibbon || ribbonCombined.indices.empty()) {
        mesh_ = nullptr;
        return Result<void>::success();
    }
 
    mesh_ = gfx_->newMeshFromArrays(ribbonCombined.posXYZ.data(), ribbonCombined.nrmXYZ.data(),
                                    ribbonCombined.uvST.data(), ribbonCombined.vertexCount(),
                                    ribbonCombined.indices.data(), ribbonCombined.indexCount());
    if (!mesh_) {
        return Result<void>::failure(Diagnostic::error(
            DiagnosticCode::Failed, "GroomInstance::rebuild: mesh upload failed", "hair.groom.mesh"));
    }
 
    return ensureDrawResources();
}
 
void GroomInstance::draw() { draw(lastModel_); }
 
void GroomInstance::draw(const glm::mat4 &model) {
    lastModel_ = model;
    if (!gfx_ || !mesh_ || !shader_ || !texture_) return;
    applyShadingParams();
    const Color tint(1.f, 1.f, 1.f, 1.f);
    gfx_->drawMeshShader(mesh_, model, texture_, tint, shader_);
}
 
int GroomInstance::getCurveCount() const {
    int total = 0;
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *g = asset_.groupAt(gi);
        if (g) total += int(g->strands.curveCount());
    }
    return total;
}
 
int GroomInstance::getPointCount() const {
    int total = 0;
    for (size_t gi = 0; gi < asset_.groupCount(); ++gi) {
        const GroomGroup *g = asset_.groupAt(gi);
        if (g) total += int(g->strands.pointCount());
    }
    return total;
}
 
}  // namespace eve::graphics::hair