ClothModel.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/Value.h"
 
#include <cstdint>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::physics {
 
enum class ClothConstraintKind : uint8_t {
    Structural,
    Shear,
    Bend,
};
 
struct ClothModelParticle {
    float x           = 0.f;
    float y           = 0.f;
    float z           = 0.f;
    float inverseMass = 1.f;
};
 
struct ClothModelTriangle {
    int vertices[3] = {0, 0, 0};
};
 
struct ClothModelDistanceConstraint {
    int                 a          = 0;
    int                 b          = 0;
    float               restLength = 0.f;
    ClothConstraintKind kind       = ClothConstraintKind::Structural;
};
 
struct ClothModelFoldConstraint {
    int a         = 0;
    int b         = 0;
    int oppositeA = 0;
    int oppositeB = 0;
};
 
struct ClothModelTetherConstraint {
    int   particle  = 0;
    int   anchor    = 0;
    float maxLength = 0.f;
};
 
class EVENGINE_API_DOMAINS ClothModel {
public:
    static constexpr uint32_t SchemaVersion = 1;
 
    [[nodiscard("check cloth model bake outcome")]]
    static eve::Result<ClothModel> fromTriangles(std::span<const float> positions, std::span<const int> triangleIndices,
                                                 std::span<const float> inverseMasses = {});
 
    [[nodiscard("check cloth grid model outcome")]]
    static eve::Result<ClothModel> grid(int cols, int rows, float spacing, float originX, float originY, float originZ);
 
    [[nodiscard("check cloth model decode outcome")]]
    static eve::Result<ClothModel> fromValue(const eve::Value& value);
 
    [[nodiscard("check cloth model JSON decode outcome")]]
    static eve::Result<ClothModel> fromJson(std::string_view json);
 
    [[nodiscard]] eve::Value toValue() const;
 
    [[nodiscard("check cloth model JSON encode outcome")]]
    eve::Result<std::string> toJson() const;
 
    [[nodiscard]] uint32_t schemaVersion() const noexcept { return SchemaVersion; }
    [[nodiscard]] std::span<const ClothModelParticle> particles() const noexcept { return particles_; }
    [[nodiscard]] std::span<const ClothModelTriangle> triangles() const noexcept { return triangles_; }
    [[nodiscard]] std::span<const ClothModelDistanceConstraint> distanceConstraints() const noexcept {
        return distanceConstraints_;
    }
    [[nodiscard]] std::span<const ClothModelFoldConstraint> foldConstraints() const noexcept {
        return foldConstraints_;
    }
    [[nodiscard]] std::span<const ClothModelTetherConstraint> tetherConstraints() const noexcept {
        return tetherConstraints_;
    }
    [[nodiscard]] bool isClosed() const noexcept { return closed_; }
    [[nodiscard]] float restVolume() const noexcept { return restVolume_; }
    [[nodiscard]] int gridCols() const noexcept { return gridCols_; }
    [[nodiscard]] int gridRows() const noexcept { return gridRows_; }
    [[nodiscard]] float gridSpacing() const noexcept { return gridSpacing_; }
 
private:
    std::vector<ClothModelParticle>           particles_;
    std::vector<ClothModelTriangle>           triangles_;
    std::vector<ClothModelDistanceConstraint> distanceConstraints_;
    std::vector<ClothModelFoldConstraint>     foldConstraints_;
    std::vector<ClothModelTetherConstraint>   tetherConstraints_;
    bool                                      closed_      = false;
    float                                     restVolume_  = 0.f;
    int                                       gridCols_    = 0;
    int                                       gridRows_    = 0;
    float                                     gridSpacing_ = 0.f;
};
 
}  // namespace eve::physics