AnimSkin.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/AnimMath.h"
#include "common/Result.h"
 
#include <array>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::model3d {
class ModelData;
}
 
namespace eve::graphics {
class Graphics;
class Mesh;
}  // namespace eve::graphics
 
namespace eve::animation {
 
class AnimSkeleton;
class AnimPose;
 
struct AnimSkinStreamData {
    int vertexCount = 0;
    std::vector<float> bindPositions;
    std::vector<float> bindNormals;
    std::vector<int> skeletonBones;
    std::vector<std::string> boneNames;
    std::vector<std::array<float, 16>> inverseBindMatrices;
    std::vector<int> vertexSkinJoints;
    std::vector<float> vertexWeights;
};
 
class EVENGINE_API_WORLD AnimSkin {
public:
    static constexpr int kMaxInfluences = 4;
 
    AnimSkin()  = default;
    ~AnimSkin() = default;
 
    AnimSkin(const AnimSkin&)            = delete;
    AnimSkin& operator=(const AnimSkin&) = delete;
 
    static AnimSkin* fromModel(const model3d::ModelData* model, int meshIndex, const AnimSkeleton* skeleton);
 
    [[nodiscard]] static Result<std::unique_ptr<AnimSkin>> fromStreams(AnimSkinStreamData streams);
 
    int getVertexCount() const { return vertexCount_; }
    int getBoneCount() const { return static_cast<int>(skeletonBone_.size()); }
    int getInfluenceCount() const { return kMaxInfluences; }
 
    int         getSkeletonBone(int skinBoneIndex) const;
    std::string getSkinBoneName(int skinBoneIndex) const;
 
    float getInverseBindElement(int skinBoneIndex, int elementIndex) const;
 
    bool updateMatrixPalette(const AnimPose* pose) const;
    float getMatrixPaletteElement(int skinBoneIndex, int elementIndex) const;
    bool bindGpuMesh(graphics::Graphics* gfx, graphics::Mesh* mesh);
    bool updateGpuMesh(graphics::Mesh* mesh, const AnimPose* pose) const;
 
    void skinPositions(const AnimPose* pose, float* outPosXYZ) const;
 
    bool skinPositionsTo(const AnimPose* pose, std::vector<float>& outPosXYZ) const;
 
    bool updateSkinnedPositions(const AnimPose* pose);
 
    bool hasSkinnedPositions() const { return skinnedValid_; }
 
    float getSkinnedPositionX(int vertexIndex) const;
    float getSkinnedPositionY(int vertexIndex) const;
    float getSkinnedPositionZ(int vertexIndex) const;
 
    std::vector<float> getSkinnedPositions() const;
 
    bool updateSkinnedNormals(const AnimPose* pose);
 
    bool hasSkinnedNormals() const { return skinnedNrmValid_; }
 
    std::vector<float> getSkinnedNormals() const;
 
    bool applyToMesh(graphics::Graphics* gfx, graphics::Mesh* mesh, const AnimPose* pose);
 
    float getBindPositionX(int vertexIndex) const;
    float getBindPositionY(int vertexIndex) const;
    float getBindPositionZ(int vertexIndex) const;
 
    int   getVertexBone(int vertexIndex, int influenceIndex) const;
    int   getVertexSkinJoint(int vertexIndex, int influenceIndex) const;
    float getVertexWeight(int vertexIndex, int influenceIndex) const;
 
private:
    struct Influence {
        int   bone   = -1;  // index into skeletonBone_ / inverseBind_
        float weight = 0.f;
    };
 
    void requireVertex(int vertexIndex) const;
    void requireSkinBone(int skinBoneIndex) const;
 
    int                        vertexCount_ = 0;
    std::vector<float>         bindPos_;       // xyz packed
    std::vector<Influence>     influences_;    // vertexCount_ * kMaxInfluences
    std::vector<int>           skeletonBone_;  // skin joint → skeleton bone
    std::vector<std::string>   skinBoneNames_;
    std::vector<Mat4>          inverseBind_;
    std::vector<float>         bindNrm_;         // xyz packed, may be empty
    std::vector<float>         skinnedPos_;      // xyz packed cache
    std::vector<float>         skinnedNrm_;      // xyz packed cache
    mutable std::vector<Mat4>  skinMatrices_;    // reused per-frame palette scratch
    mutable std::vector<float> normalMatrices_;  // reused 3x3 palette scratch
    mutable bool               matrixPaletteValid_ = false;
    bool                       skinnedValid_    = false;
    bool                       skinnedNrmValid_ = false;
};
 
}  // namespace eve::animation