AnimLattice.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include <string>
#include <vector>
 
namespace eve::model3d {
class ModelData;
}
 
namespace eve::animation {
 
class EVENGINE_API_WORLD AnimLattice {
public:
    static constexpr int kMinDivisions = 2;
 
    AnimLattice();
 
    explicit AnimLattice(int divX, int divY, int divZ);
 
    AnimLattice(const AnimLattice&)            = delete;
    AnimLattice& operator=(const AnimLattice&) = delete;
 
    // ---- lattice frame ----
 
    void setDivisions(int divX, int divY, int divZ);
    int  getDivisionsX() const { return divX_; }
    int  getDivisionsY() const { return divY_; }
    int  getDivisionsZ() const { return divZ_; }
 
    void  setSize(float sx, float sy, float sz);
    float getSizeX() const { return sizeX_; }
    float getSizeY() const { return sizeY_; }
    float getSizeZ() const { return sizeZ_; }
 
    void  setOrigin(float ox, float oy, float oz);
    float getOriginX() const { return originX_; }
    float getOriginY() const { return originY_; }
    float getOriginZ() const { return originZ_; }
 
    void setClamp(bool clamp) { clamp_ = clamp; }
    bool getClamp() const { return clamp_; }
 
    // ---- control points ----
 
    int getPointCount() const { return static_cast<int>(points_.size()); }
 
    void setPointScale(int ix, int iy, int iz, float sx, float sy, float sz);
    void setPointOffset(int ix, int iy, int iz, float dx, float dy, float dz);
 
    void setScale(float sx, float sy, float sz);
    void reset();
 
    float getPointScaleX(int ix, int iy, int iz) const;
    float getPointScaleY(int ix, int iy, int iz) const;
    float getPointScaleZ(int ix, int iy, int iz) const;
    float getPointOffsetX(int ix, int iy, int iz) const;
    float getPointOffsetY(int ix, int iy, int iz) const;
    float getPointOffsetZ(int ix, int iy, int iz) const;
 
    // ---- binding ----
 
    static AnimLattice* fromModel(const model3d::ModelData* model, int meshIndex, int divX, int divY, int divZ);
 
    void bindModel(const model3d::ModelData* model, int meshIndex);
 
    void bindPositions(const float* posXYZ, int count);
 
    void clearBind();
    int  getVertexCount() const { return vertexCount_; }
 
    float getBindPositionX(int vertexIndex) const;
    float getBindPositionY(int vertexIndex) const;
    float getBindPositionZ(int vertexIndex) const;
 
    // ---- deformation ----
 
    void deformPositions(const float* inPosXYZ, float* outPosXYZ, int count) const;
 
    bool deformPositionsTo(const std::vector<float>& inPosXYZ, std::vector<float>& outPosXYZ) const;
 
    bool deformNormals(const float* posXYZ, const float* inNrmXYZ, float* outNrmXYZ, int count) const;
 
    bool updateDeformedPositions(const std::vector<float>& inPosXYZ);
 
    bool updateDeformedPositions();
 
    bool updateDeformedNormals(const std::vector<float>& posXYZ, const std::vector<float>& inNrmXYZ);
 
    bool hasDeformedPositions() const { return deformedValid_; }
 
    bool hasDeformedNormals() const { return deformedNrmValid_; }
 
    float getDeformedPositionX(int vertexIndex) const;
    float getDeformedPositionY(int vertexIndex) const;
    float getDeformedPositionZ(int vertexIndex) const;
 
    std::vector<float> getDeformedPositions() const;
    std::vector<float> getDeformedNormals() const;
 
private:
    struct ControlPoint {
        float ox = 0.f, oy = 0.f, oz = 0.f;
        float sx = 1.f, sy = 1.f, sz = 1.f;
    };
 
    void requirePoint(int ix, int iy, int iz) const;
    void requireVertex(int vertexIndex) const;
    int  pointIndex(int ix, int iy, int iz) const;
    void computeCell(float x, float y, float z, int& i0, int& j0, int& k0, float& fu, float& fv, float& fw) const;
 
    int   divX_    = kMinDivisions;
    int   divY_    = kMinDivisions;
    int   divZ_    = kMinDivisions;
    float sizeX_   = 1.f;
    float sizeY_   = 1.f;
    float sizeZ_   = 1.f;
    float originX_ = 0.f;
    float originY_ = 0.f;
    float originZ_ = 0.f;
    bool  clamp_   = true;
 
    std::vector<ControlPoint> points_;
    std::vector<float>        bindPos_;  // xyz packed
    int                       vertexCount_ = 0;
 
    std::vector<float> deformedPos_;
    std::vector<float> deformedNrm_;
    bool               deformedValid_    = false;
    bool               deformedNrmValid_ = false;
};
 
}  // namespace eve::animation