DynamicBoneSolver.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <string>
#include <vector>
 
namespace eve::animation {
 
class AnimPose;
class AnimSkeleton;
 
class DynamicBoneForceField {
public:
    virtual ~DynamicBoneForceField() = default;
    virtual void sampleForce(float x, float y, float z, float time, float &outX, float &outY, float &outZ) const = 0;
};
 
struct DynamicBoneDebugParticle { int chain=0,particle=0; float x=0.f,y=0.f,z=0.f,radius=0.f; bool sleeping=false; };
struct DynamicBoneDebugCollider { float startX=0.f,startY=0.f,startZ=0.f,endX=0.f,endY=0.f,endZ=0.f,radius=0.f; bool capsule=false,inside=false,enabled=true; };
struct DynamicBoneDebugSnapshot { std::vector<DynamicBoneDebugParticle> particles; std::vector<DynamicBoneDebugCollider> colliders; };
struct DynamicBoneUpdateStats { int activeChains=0,sleepingChains=0,particles=0,substeps=0,colliderTests=0,selfCollisionTests=0; };
 
class EVENGINE_API_WORLD DynamicBoneSolver {
public:
    explicit DynamicBoneSolver(AnimSkeleton *skeleton);
    ~DynamicBoneSolver();
    DynamicBoneSolver(const DynamicBoneSolver &)            = default;
    DynamicBoneSolver &operator=(const DynamicBoneSolver &) = default;
 
    void setSkeleton(AnimSkeleton *skeleton);
    AnimSkeleton *getSkeleton() const { return skeleton_; }
 
    int addChain(int rootBone, int endBone, float stiffness, float damping, float inertia,
                 float gravityScale = 1.f, float radius = 0.f, int iterations = 4);
    int addChainByName(const std::string &rootBone, const std::string &endBone, float stiffness,
                       float damping, float inertia, float gravityScale = 1.f, float radius = 0.f,
                       int iterations = 4);
    int getChainCount() const;
    void clearChains();
    void setChainEnabled(int chainIndex, bool enabled);
    bool isChainEnabled(int chainIndex) const;
    void setChainFreezeAxis(int chainIndex, int axis);
    void setChainSelfCollision(int chainIndex, bool enabled);
    void setChainParticleParameters(int chainIndex, int particleIndex, float stiffness, float damping, float inertia,
                                    float gravityScale, float radius);
    void setChainEndLength(int chainIndex, float length);
    void setChainEndOffset(int chainIndex, float x, float y, float z);
    void clearChainEnd(int chainIndex);
 
    void setGlobalGravity(float x, float y, float z);
    void setExternalForce(float x, float y, float z);
    void setForceField(const DynamicBoneForceField *forceField) { forceField_ = forceField; }
    const DynamicBoneForceField *getForceField() const { return forceField_; }
    float getGlobalGravityX() const { return globalGravityX_; }
    float getGlobalGravityY() const { return globalGravityY_; }
    float getGlobalGravityZ() const { return globalGravityZ_; }
    void setWeight(float weight);
    float getWeight() const { return weight_; }
    void setUpdateRate(float updatesPerSecond);
    float getUpdateRate() const { return updateRate_; }
    void setTeleportThreshold(float distance);
    float getTeleportThreshold() const { return teleportThreshold_; }
    void setObjectMoveResponse(float value);
    float getObjectMoveResponse() const { return objectMoveResponse_; }
    void setDistanceReference(float x, float y, float z);
    void setDistanceLimit(float value);
    bool isChainSleeping(int chainIndex) const;
 
    void addColliderSphere(float centerX, float centerY, float centerZ, float radius);
    void addBoneColliderSphere(int boneIndex, float offsetX, float offsetY, float offsetZ, float radius);
    void addColliderCapsule(float startX, float startY, float startZ, float endX, float endY, float endZ,
                            float radius);
    void addBoneColliderCapsule(int boneIndex, float startX, float startY, float startZ, float endX, float endY,
                                float endZ, float radius);
    void clearColliders();
    int getColliderCount() const;
    void removeCollider(int index);
    void setColliderEnabled(int index, bool enabled);
    void setColliderInside(int index, bool inside);
    void setColliderRadius(int index, float radius);
    void reset();
    void update(AnimPose *pose, float dt);
    DynamicBoneDebugSnapshot debugSnapshot() const;
    DynamicBoneUpdateStats getLastUpdateStats() const { return lastUpdateStats_; }
 
private:
    struct Vec3 { float x = 0.f, y = 0.f, z = 0.f; };
    struct Collider {
        int bone = -1;
        Vec3 offset;
        Vec3 endOffset;
        Vec3 center;
        Vec3 end;
        float radius = 0.f;
        bool capsule = false;
        bool enabled = true;
        bool inside = false;
    };
    struct Chain {
        struct ParticleParameters {
            float stiffness = 0.5f, damping = 0.7f, inertia = 0.9f;
            float gravityScale = 1.f, radius = 0.f;
        };
        std::vector<int> bones;
        std::vector<float> restLength;
        std::vector<Vec3> current, previous, target;
        std::vector<ParticleParameters> particleParameters;
        float stiffness = 0.5f, damping = 0.7f, inertia = 0.9f;
        int freezeAxis = 0;
        float gravityScale = 1.f, radius = 0.f;
        float endLength = 0.f;
        Vec3 endOffset;
        int endMode = 0;
        int iterations = 4;
        bool enabled = true, initialized = false, sleeping = false, selfCollision = false;
    };
 
    std::vector<int> buildChainByIndexes(int rootBone, int endBone) const;
    bool validateChain(const std::vector<int> &bones) const;
    void captureTargets(Chain &chain, const AnimPose &pose);
    void initializeChain(Chain &chain);
    void simulateChain(Chain &chain, float dt);
    void constrainSegment(Chain &chain, size_t particleIndex) const;
    void writeChainRotations(const Chain &chain, AnimPose &pose) const;
    void updateColliderCenters(const AnimPose &pose);
    bool resolveCollider(const Collider &collider, float particleRadius, Vec3 &point) const;
 
    AnimSkeleton *skeleton_ = nullptr;
    float globalGravityX_ = 0.f, globalGravityY_ = -9.8f, globalGravityZ_ = 0.f;
    float externalForceX_ = 0.f, externalForceY_ = 0.f, externalForceZ_ = 0.f;
    float weight_ = 1.f, updateRate_ = 60.f, teleportThreshold_ = 2.f;
    float objectMoveResponse_ = 1.f, distanceLimit_ = 0.f;
    Vec3 distanceReference_;
    const DynamicBoneForceField *forceField_ = nullptr;
    float simulationTime_ = 0.f;
    DynamicBoneUpdateStats lastUpdateStats_;
    std::vector<Chain> chains_;
    std::vector<Collider> colliders_;
};
 
}  // namespace eve::animation