Mesh.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "graphics/Drawable.h"
 
#include <cstdint>
#include <map>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
struct aiMesh;
 
namespace eve::graphics {
 
class EVENGINE_API_BACKENDS Mesh : public Drawable {
public:
    int   indexCount = 0;
    void *gpuHandle  = nullptr;  // vulkan::GpuMesh*
    int gpuVertexCount = 0;
    bool hasGpuSkinning() const { return gpuSkinned_; }
    int getSkinPaletteCount() const { return static_cast<int>(skinPalette_.size() / 16u); }
    [[nodiscard]] Result<void> setSkinPalette(const float* matrices, int matrixCount);
    const std::vector<float> &skinPalette() const { return skinPalette_; }
    void markGpuSkinned(bool value) { gpuSkinned_ = value; }
 
    [[nodiscard]] Result<void> setTexcoordSet(uint32_t set, std::span<const float> values);
    std::span<const float> texcoordSet(uint32_t set) const;
    uint64_t texcoordRevision() const { return texcoordRevision_; }
    float boundsCx     = 0.f;
    float boundsCy     = 0.f;
    float boundsCz     = 0.f;
    float boundsRadius = 0.f;
 
    bool hasBounds() const { return boundsRadius > 0.f; }
 
    void computeBounds(const float *posXYZ, int vertexCount);
 
    void draw(Graphics * /*gfx*/, const glm::mat4 & /*matrix*/) const override {}
    void drawOcclusion(Graphics *gfx, const glm::mat4 &matrix) const override;
 
    // ---- morph targets (CPU) ----
    void clearMorphData();
    void initMorphBase(int vertexCount, const float *posXYZ, const float *nrmXYZ = nullptr,
                       const float *uvST = nullptr);
    bool addMorphTarget(const std::string &name, const float *deltaPosXYZ);
    bool addMorphTargetAbsolute(const std::string &name, const float *absPosXYZ);
 
    int getVertexCount() const;
    int getMorphCount() const;
    std::string getMorphName(int index) const;
    bool hasMorph(const std::string &name) const;
    bool setMorphWeight(const std::string &name, float weight);
    float getMorphWeight(const std::string &name) const;
    void clearMorphWeights();
    bool isMorphDirty() const { return morphDirty_; }
    void markMorphClean() { morphDirty_ = false; }
    bool hasMorphData() const { return !basePos_.empty(); }
 
    void computeMorphedPositions(std::vector<float> &outPos, std::vector<float> &outNrm) const;
 
    const std::vector<float> &baseUv() const { return baseUv_; }
 
    void captureImportedAttributes(const ::aiMesh &mesh);
    [[nodiscard]] Result<void> setTangentFrame(std::span<const float> tangents, std::span<const float> bitangents);
    [[nodiscard]] Result<void> validateTangentFrame(std::span<const float> tangents,
                                                    std::span<const float> bitangents) const;
    [[nodiscard]] Result<void> adoptTangentFrame(std::vector<float> &&tangents, std::vector<float> &&bitangents);
    [[nodiscard]] Result<void> validateMotionHighlights(std::span<const float> values) const;
    [[nodiscard]] Result<void> adoptMotionHighlights(std::vector<float> &&values);
    [[nodiscard]] std::span<const float> motionHighlights() const { return motionHighlights_; }
    [[nodiscard]] Result<void> validateVegetationFactors(std::span<const float> values) const;
    [[nodiscard]] Result<void> adoptVegetationFactors(std::vector<float> &&values);
    [[nodiscard]] std::span<const float> vegetationFactors() const { return vegetationFactors_; }
    [[nodiscard]] Result<void> validateVegetationDeformationFactors(std::span<const float> values) const;
    [[nodiscard]] Result<void> adoptVegetationDeformationFactors(std::vector<float> &&values);
    [[nodiscard]] std::span<const float> vegetationDeformationFactors() const { return vegetationDeformationFactors_; }
    int getUvChannelCount() const { return static_cast<int>(importedUvs_.size()); }
    int getColorChannelCount() const { return static_cast<int>(importedColors_.size()); }
    bool hasImportedTangents() const { return !importedTangents_.empty(); }
    const std::vector<float> &importedUv(int channel) const;
    const std::vector<float> &importedColor(int channel) const;
    const std::vector<float> &importedTangents() const { return importedTangents_; }
    const std::vector<float> &importedBitangents() const { return importedBitangents_; }
 
private:
    std::map<uint32_t, std::vector<float>> texcoords_;
    uint64_t                               texcoordRevision_ = 0;
 
    struct MorphTarget {
        std::string name;
        std::vector<float> deltaPos;  // xyz packed, size = vertexCount*3
    };
 
    std::vector<float> basePos_;
    std::vector<float> baseNrm_;
    std::vector<float> baseUv_;
    std::vector<MorphTarget> morphs_;
    std::unordered_map<std::string, float> morphWeights_;
    bool morphDirty_ = false;
    std::vector<std::vector<float>> importedUvs_;     // xy packed per channel
    std::vector<std::vector<float>> importedColors_;  // rgba packed per channel
    std::vector<float> importedTangents_;             // xyz packed
    std::vector<float> importedBitangents_;            // xyz packed
    std::vector<float>                     motionHighlights_;
    std::vector<float>                     vegetationFactors_;
    std::vector<float>                     vegetationDeformationFactors_;
    bool gpuSkinned_ = false;
    std::vector<float> skinPalette_;
};
 
}  // namespace eve::graphics