Mesh.cpp

浏览该文件的文档.

#include "graphics/Mesh.h"
 
#include <assimp/mesh.h>
 
#include "graphics/Graphics.h"
 
#include <algorithm>
#include <cmath>
 
namespace eve::graphics {
Result<void> Mesh::setTexcoordSet(uint32_t set, std::span<const float> values) {
    if (gpuVertexCount <= 0 || values.size() != size_t(gpuVertexCount) * 2 ||
        std::any_of(values.begin(), values.end(), [](float x) { return !std::isfinite(x); }))
        return Result<void>::failure(
            Diagnostic::error(DiagnosticCode::InvalidArgument, "UV channel must match mesh vertices"));
    std::vector<float> owned(values.begin(), values.end());
    texcoords_.insert_or_assign(set, std::move(owned));
    ++texcoordRevision_;
    return Result<void>::success();
}
std::span<const float> Mesh::texcoordSet(uint32_t set) const {
    auto found = texcoords_.find(set);
    return found == texcoords_.end() ? std::span<const float>{} : std::span<const float>(found->second);
}
 
 
namespace {
const std::vector<float> kEmptyAttribute;
}
 
void Mesh::captureImportedAttributes(const ::aiMesh &mesh) {
    importedUvs_.clear();
    for (unsigned channel = 0; channel < mesh.GetNumUVChannels(); ++channel) {
        if (!mesh.HasTextureCoords(channel)) continue;
        std::vector<float> values;
        values.reserve(size_t(mesh.mNumVertices) * 2u);
        for (unsigned i = 0; i < mesh.mNumVertices; ++i) {
            values.push_back(mesh.mTextureCoords[channel][i].x);
            values.push_back(mesh.mTextureCoords[channel][i].y);
        }
        importedUvs_.push_back(std::move(values));
    }
    importedColors_.clear();
    for (unsigned channel = 0; channel < mesh.GetNumColorChannels(); ++channel) {
        if (!mesh.HasVertexColors(channel)) continue;
        std::vector<float> values;
        values.reserve(size_t(mesh.mNumVertices) * 4u);
        for (unsigned i = 0; i < mesh.mNumVertices; ++i) {
            const aiColor4D &c = mesh.mColors[channel][i];
            values.insert(values.end(), {c.r, c.g, c.b, c.a});
        }
        importedColors_.push_back(std::move(values));
    }
    importedTangents_.clear();
    importedBitangents_.clear();
    if (mesh.HasTangentsAndBitangents()) {
        importedTangents_.reserve(size_t(mesh.mNumVertices) * 3u);
        importedBitangents_.reserve(size_t(mesh.mNumVertices) * 3u);
        for (unsigned i = 0; i < mesh.mNumVertices; ++i) {
            const aiVector3D &t = mesh.mTangents[i];
            const aiVector3D &b = mesh.mBitangents[i];
            importedTangents_.insert(importedTangents_.end(), {t.x, t.y, t.z});
            importedBitangents_.insert(importedBitangents_.end(), {b.x, b.y, b.z});
        }
    }
}
 
const std::vector<float> &Mesh::importedUv(int channel) const {
    return channel >= 0 && static_cast<size_t>(channel) < importedUvs_.size()
               ? importedUvs_[static_cast<size_t>(channel)]
               : kEmptyAttribute;
}
 
const std::vector<float> &Mesh::importedColor(int channel) const {
    return channel >= 0 && static_cast<size_t>(channel) < importedColors_.size()
               ? importedColors_[static_cast<size_t>(channel)]
               : kEmptyAttribute;
}
 
Result<void> Mesh::setSkinPalette(const float* matrices, int matrixCount) {
    if (!matrices || matrixCount <= 0 || static_cast<size_t>(matrixCount) > skinPalette_.max_size() / 16u)
        return Result<void>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument, "Invalid skin palette size"));
    const size_t count = static_cast<size_t>(matrixCount) * 16u;
    for (size_t i = 0; i < count; ++i)
        if (!std::isfinite(matrices[i]))
            return Result<void>::failure(
                Diagnostic::error(DiagnosticCode::InvalidArgument, "Non-finite skin palette matrix"));
    std::vector<float> replacement(matrices, matrices + count);
    skinPalette_.swap(replacement);
    return Result<void>::success();
}
 
void Mesh::computeBounds(const float *posXYZ, int vertexCount) {
    boundsCx     = 0.f;
    boundsCy     = 0.f;
    boundsCz     = 0.f;
    boundsRadius = 0.f;
    if (!posXYZ || vertexCount <= 0) return;
 
    const size_t n = size_t(vertexCount);
    glm::vec3    c(0.f);
    for (size_t i = 0; i < n; ++i) {
        c.x += posXYZ[i * 3u + 0u];
        c.y += posXYZ[i * 3u + 1u];
        c.z += posXYZ[i * 3u + 2u];
    }
    c /= float(n);
    boundsCx = c.x;
    boundsCy = c.y;
    boundsCz = c.z;
 
    float r = 0.f;
    for (size_t i = 0; i < n; ++i) {
        const float dx = posXYZ[i * 3u + 0u] - c.x;
        const float dy = posXYZ[i * 3u + 1u] - c.y;
        const float dz = posXYZ[i * 3u + 2u] - c.z;
        const float d  = std::sqrt(dx * dx + dy * dy + dz * dz);
        if (d > r) r = d;
    }
    // Degenerate (single-point) meshes still get a tiny non-zero sphere so
    // hasBounds() stays meaningful and the culler never drops point geometry.
    boundsRadius = r > 0.f ? r : 1e-4f;
}
 
void Mesh::drawOcclusion(Graphics *gfx, const glm::mat4 &matrix) const {
    if (!gfx || !getCastOcclusion()) return;
    const float x = matrix[3][0];
    const float y = matrix[3][1];
    const float w = std::sqrt(matrix[0][0] * matrix[0][0] + matrix[0][1] * matrix[0][1]);
    const float h = std::sqrt(matrix[1][0] * matrix[1][0] + matrix[1][1] * matrix[1][1]);
    if (w <= 0.f || h <= 0.f) return;
    gfx->drawOcclusionSolid(x, y, w, h);
}
 
void Mesh::clearMorphData() {
    basePos_.clear();
    baseNrm_.clear();
    baseUv_.clear();
    morphs_.clear();
    morphWeights_.clear();
    morphDirty_ = false;
}
 
void Mesh::initMorphBase(int vertexCount, const float *posXYZ, const float *nrmXYZ,
                         const float *uvST) {
    clearMorphData();
    if (vertexCount <= 0 || !posXYZ) return;
    const size_t n = size_t(vertexCount);
    basePos_.assign(posXYZ, posXYZ + n * 3);
    if (nrmXYZ)
        baseNrm_.assign(nrmXYZ, nrmXYZ + n * 3);
    else
        baseNrm_.assign(n * 3, 0.f);
    if (uvST)
        baseUv_.assign(uvST, uvST + n * 2);
    else
        baseUv_.assign(n * 2, 0.f);
}
 
bool Mesh::addMorphTarget(const std::string &name, const float *deltaPosXYZ) {
    if (name.empty() || !deltaPosXYZ || basePos_.empty()) return false;
    if (hasMorph(name)) return false;
    MorphTarget t;
    t.name = name;
    t.deltaPos.assign(deltaPosXYZ, deltaPosXYZ + basePos_.size());
    morphs_.push_back(std::move(t));
    morphWeights_[name] = 0.f;
    morphDirty_ = true;
    return true;
}
 
bool Mesh::addMorphTargetAbsolute(const std::string &name, const float *absPosXYZ) {
    if (name.empty() || !absPosXYZ || basePos_.empty()) return false;
    if (hasMorph(name)) return false;
    MorphTarget t;
    t.name = name;
    t.deltaPos.resize(basePos_.size());
    for (size_t i = 0; i < basePos_.size(); ++i)
        t.deltaPos[i] = absPosXYZ[i] - basePos_[i];
    morphs_.push_back(std::move(t));
    morphWeights_[name] = 0.f;
    morphDirty_ = true;
    return true;
}
 
int Mesh::getVertexCount() const {
    if (!basePos_.empty()) return int(basePos_.size() / 3);
    return gpuVertexCount;
}
 
int Mesh::getMorphCount() const { return int(morphs_.size()); }
 
std::string Mesh::getMorphName(int index) const {
    if (index < 0 || size_t(index) >= morphs_.size()) return {};
    return morphs_[size_t(index)].name;
}
 
bool Mesh::hasMorph(const std::string &name) const {
    return morphWeights_.find(name) != morphWeights_.end();
}
 
bool Mesh::setMorphWeight(const std::string &name, float weight) {
    auto it = morphWeights_.find(name);
    if (it == morphWeights_.end()) return false;
    if (weight < 0.f) weight = 0.f;
    if (weight > 1.f) weight = 1.f;
    if (std::fabs(it->second - weight) > 1e-6f) {
        it->second = weight;
        morphDirty_ = true;
    }
    return true;
}
 
float Mesh::getMorphWeight(const std::string &name) const {
    auto it = morphWeights_.find(name);
    return it == morphWeights_.end() ? 0.f : it->second;
}
 
void Mesh::clearMorphWeights() {
    for (auto &kv : morphWeights_) {
        if (kv.second != 0.f) {
            kv.second = 0.f;
            morphDirty_ = true;
        }
    }
}
 
void Mesh::computeMorphedPositions(std::vector<float> &outPos, std::vector<float> &outNrm) const {
    outPos = basePos_;
    outNrm = baseNrm_;
    if (outPos.empty()) return;
    for (const MorphTarget &t : morphs_) {
        auto it = morphWeights_.find(t.name);
        const float w = (it == morphWeights_.end()) ? 0.f : it->second;
        if (std::fabs(w) < 1e-8f) continue;
        for (size_t i = 0; i < outPos.size() && i < t.deltaPos.size(); ++i)
            outPos[i] += t.deltaPos[i] * w;
    }
}
 
}  // namespace eve::graphics