Animation.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "animation/MotionBuilder.h"
#include "animation/MotionSequence.h"
#include "animation/MotionRuntime.h"
#include "animation/MotionTypes.h"
#include "animation/Tween.h"
#include "common/Module.h"
#include "common/Time.h"
 
#include <string>
#include <memory>
#include <unordered_map>
#include <vector>
 
namespace ssq {
class Class;
}
 
namespace eve::model3d {
class ModelData;
}
 
namespace eve::graphics {
class Graphics;
}
 
namespace eve::animation {
 
class AnimSkeleton;
class AnimClip;
class AnimPose;
class AnimPlayer;
class AnimGraph;
class AnimBoneMask;
class AnimLayerMixer;
class AnimStateMachine;
class MotionDatabase;
class MotionMatcher;
class ControlAnim;
class ControlPose;
class PhysicalBalancePose;
class AnimSkin;
class AnimLattice;
class AnimTrail;
class AnimBatch;
class AnimConstraintStack;
class AnimSyncGroup;
class DynamicBoneSolver;
class FootIKSolver;
class SpriteSheet;
class SpriteClip;
class SpriteAnim;
class SpineAtlas;
class SpineSkeletonData;
class SpineSkeleton;
class SpineAnim;
 
class EVENGINE_API_WORLD Animation : public Module {
public:
    Module_REG(Animation);
    // Declared, not `= default`: class-level dllexport forces MSVC to compute the
    // defaulted constructor's exception specification, which needs the destructor of
    // every member -- and `SpriteSheet` is only forward-declared here (line 47), so an
    // in-class `= default` is C2027 "can't delete an incomplete type". Defined in
    // Animation.cpp, which includes animation/SpriteSheet.h.
    Animation();
    ~Animation() override;
    // `spriteSequenceCache_` is a container of `unique_ptr`: dllexport instantiates
    // every member, so the implicitly-defined copy operations would instantiate the
    // container's copy (hard C2280). Copy is deleted; no move is declared because
    // `MotionRuntime motions_` is itself neither copyable nor movable
    // (MotionRuntime.h:130 deletes copy and declares no move), which would make a
    // defaulted move operation ill-formed.
    Animation(const Animation &)            = delete;
    Animation &operator=(const Animation &) = delete;
 
    Tween *newTween(float duration = 1.f);
 
    SpriteSheet *newSpriteSheet();
    SpriteSheet *newSpriteSheetFromSequence(eve::graphics::Graphics *gfx,
                                             const std::string &pattern, int first,
                                             int last, int columns = 0);
    SpriteSheet *newSpriteSheetFromAtlasJson(eve::graphics::Graphics *gfx,
                                              const std::string &texturePath,
                                              const std::string &jsonPath);
    SpriteClip  *newSpriteClip(const std::string &name = "");
    SpriteAnim  *newSpriteAnim();
    int getSpriteSequenceCacheCount() const;
    int getSpriteSequenceCacheBytes() const;
    void clearSpriteSequenceCache();
 
    SpineAtlas        *newSpineAtlas();
    SpineSkeletonData *newSpineSkeletonData();
    SpineSkeleton     *newSpineSkeleton(SpineSkeletonData *data);
    SpineAnim         *newSpineAnim(SpineSkeleton *skeleton);
 
    SpineAtlas        *newSpineAtlasFromFile(const std::string &path);
    SpineAtlas        *newSpineAtlasFromText(const std::string &text);
    SpineSkeletonData *newSpineSkeletonDataFromFile(const std::string &path);
    SpineSkeletonData *newSpineSkeletonDataFromJson(const std::string &json);
 
    AnimSkeleton     *newSkeleton();
    AnimClip         *newClip(const std::string &name = "");
    AnimPose         *newPose(int boneCount = 0);
    AnimBatch        *newBatch();
    AnimConstraintStack *newConstraintStack(AnimSkeleton* skeleton);
    DynamicBoneSolver *newDynamicBoneSolver(AnimSkeleton *skeleton);
 
    int setupHairChain(DynamicBoneSolver *solver, const std::string &rootBone,
                       const std::string &tipBone, float stiffness = 0.12f,
                       float damping = 0.18f, float inertia = 0.8f, float endLength = 0.08f,
                       bool selfCollision = true);
 
    int setupHairHeadCollider(DynamicBoneSolver *solver, const std::string &boneName,
                              float radius = 0.12f);
 
    FootIKSolver *newFootIKSolver(AnimSkeleton *skeleton);
    AnimSyncGroup* newSyncGroup();
    AnimPlayer       *newPlayer(AnimSkeleton *skeleton);
    AnimGraph        *newGraph(AnimSkeleton *skeleton);
    AnimBoneMask* newBoneMask(AnimSkeleton* skeleton);
    AnimLayerMixer*   newLayerMixer(AnimSkeleton* skeleton);
    AnimStateMachine *newStateMachine(AnimSkeleton *skeleton);
    MotionDatabase   *newMotionDatabase(AnimSkeleton *skeleton);
    MotionMatcher    *newMotionMatcher(AnimSkeleton *skeleton, MotionDatabase *database);
 
    ControlAnim *newControlAnim(float frequencyHz = 3.f, float dampingZeta = 1.f,
                                float response = 1.f);
    ControlPose *newControlPose(AnimSkeleton *skeleton);
    PhysicalBalancePose* newPhysicalBalancePose(AnimSkeleton* skeleton);
 
    AnimSkeleton *newSkeletonFromModel(eve::model3d::ModelData *model);
    AnimClip     *newClipFromModel(eve::model3d::ModelData *model, AnimSkeleton *skeleton,
                                   int animIndex = 0);
    AnimSkeleton *newSkeletonFromAnimationFixtureText(const std::string &path);
    AnimClip *newClipFromAnimationFixtureText(const std::string &path);
 
    AnimSkin *newSkinFromModel(eve::model3d::ModelData *model, int meshIndex,
                               AnimSkeleton *skeleton);
 
    AnimLattice *newLattice(int divX = 2, int divY = 2, int divZ = 2);
 
    AnimLattice *newLatticeFromModel(eve::model3d::ModelData *model, int meshIndex,
                                     int divX = 2, int divY = 2, int divZ = 2);
 
    AnimTrail *newTrail(int capacity = 64);
 
    [[nodiscard]] MotionBuilder motion(float from, float to, float duration);
    [[nodiscard]] MotionVec2Builder motionVec2(MotionVec2 from, MotionVec2 to, float duration);
    [[nodiscard]] MotionVec3Builder motionVec3(MotionVec3 from, MotionVec3 to, float duration);
 
    [[nodiscard]] MotionBuilder punch(float from, float strength, float duration);
    [[nodiscard]] MotionBuilder shake(float from, float strength, float duration);
    [[nodiscard]] MotionVec2Builder punchVec2(MotionVec2 from, MotionVec2 strength, float duration);
    [[nodiscard]] MotionVec2Builder shakeVec2(MotionVec2 from, MotionVec2 strength, float duration);
    [[nodiscard]] MotionVec3Builder punchVec3(MotionVec3 from, MotionVec3 strength, float duration);
    [[nodiscard]] MotionVec3Builder shakeVec3(MotionVec3 from, MotionVec3 strength, float duration);
    [[nodiscard]] MotionColorBuilder motionColor(MotionColor from, MotionColor to, float duration);
    [[nodiscard]] MotionQuatBuilder motionQuat(MotionQuat from, MotionQuat to, float duration);
 
    [[nodiscard]] MotionSequence sequence();
 
    [[nodiscard]] MotionRuntime &motions() noexcept { return motions_; }
    [[nodiscard]] const MotionRuntime &motions() const noexcept { return motions_; }
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep &step);
 
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept { return lastTick_; }
 
    void update(float dt);
 
    int getTweenCount() const { return static_cast<int>(tweens_.size()); }
    int getMotionCount() const { return motions_.activeCount(); }
 
    void ensureMotionCapacity(std::size_t floatCount) { motions_.ensureCapacity(floatCount); }
    [[nodiscard]] std::size_t getMotionFloatCapacity() const noexcept {
        return motions_.floatCapacity();
    }
    [[nodiscard]] std::size_t getMotionFloatFreeCount() const noexcept {
        return motions_.floatFreeCount();
    }
    int getSpriteAnimCount() const { return static_cast<int>(spriteAnims_.size()); }
    int getSpineAnimCount() const { return static_cast<int>(spineAnims_.size()); }
    int getActiveCount() const;
 
    void clearFinished();
    void clearAll();
 
private:
    std::unordered_map<std::string, std::unique_ptr<SpriteSheet>> spriteSequenceCache_;
    friend class Tween;
    friend class SpriteAnim;
    friend class SpineAnim;
 
    void registerTween(Tween *t);
    void unregisterTween(Tween *t);
    void registerSpriteAnim(SpriteAnim *a);
    void unregisterSpriteAnim(SpriteAnim *a);
    void registerSpineAnim(SpineAnim *a);
    void unregisterSpineAnim(SpineAnim *a);
 
    std::vector<Tween *>      tweens_;
    std::vector<SpriteAnim *> spriteAnims_;
    std::vector<SpineAnim *>  spineAnims_;
    MotionRuntime             motions_;
    eve::SimulationTick       lastTick_    = eve::SimulationTick::zero();
    bool                      hasLastTick_ = false;
};
 
void exposeAnimationModelImportBindings(ssq::Class &cls);
 
}  // namespace eve::animation