SpriteAnim.h

浏览该文件的文档.

#pragma once
 
#include "common/Time.h"
 
#include <string>
#include <vector>
 
namespace eve::graphics {
class Quad;
class Renderable2D;
}
 
namespace eve::animation {
 
class Animation;
class SpriteClip;
class SpriteSheet;
 
class EVENGINE_API_WORLD SpriteAnim {
public:
    SpriteAnim();
    ~SpriteAnim();
 
    SpriteAnim(const SpriteAnim &)            = delete;
    SpriteAnim &operator=(const SpriteAnim &) = delete;
 
    void         setSheet(SpriteSheet *sheet);
    SpriteSheet *getSheet() const { return sheet_; }
 
    void       play(SpriteClip *clip);
    void       playReverse(SpriteClip *clip);
    void       stop();
    void       pause();
    void       resume();
 
    void  setSpeed(float speed);
    float getSpeed() const { return speed_; }
    void addSpeedCurveKey(float seconds, float multiplier);
    void clearSpeedCurve();
    void resetSpeedCurve();
    void setSpeedCurveLoop(bool loop) { speedCurveLoop_ = loop; }
    void setSpeedCurveInterpolation(const std::string &mode);
    float getSpeedCurveValue() const;
    void setFrame(int clipFrame);
    void step(int frames);
    void playOnce(SpriteClip *clip);
    void queue(SpriteClip *clip);
    std::string consumeEvent();
    void  setTime(float seconds);
    float getTime() const { return time_; }
    void  setLoop(bool loop);
    bool  getLoop() const;
 
    bool isPlaying() const { return playing_ && !paused_; }
    bool isPaused() const { return paused_; }
    bool isFinished() const { return finished_; }
    int  getLoopCount() const { return loopCount_; }
    bool consumeCompleted();
    int  consumeLooped();
 
    SpriteClip *getClip() const { return clip_; }
    int getClipFrame() const { return clipFrame_; }
    int getSheetFrame() const;
 
    void           bindQuad(graphics::Quad *quad);
    void           unbindQuad();
    graphics::Quad *getBoundQuad() const { return boundQuad_; }
    void bindSprite(graphics::Renderable2D *sprite);
 
    void applyToQuad(graphics::Quad *quad) const;
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep &step);
    [[nodiscard]] bool hasCurrentTick() const noexcept { return hasLastTick_; }
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept { return lastTick_; }
    bool update(float dt);
 
private:
    friend class Animation;
 
    void setOwner(Animation *owner) { owner_ = owner; }
    Animation *owner() const { return owner_; }
 
    void refreshFrame();
    void syncBoundQuad();
    float sampleSpeedCurve(float seconds) const;
 
    struct SpeedKey {
        float time = 0.f;
        float value = 1.f;
    };
 
    Animation         *owner_      = nullptr;
    SpriteSheet       *sheet_      = nullptr;
    SpriteClip        *clip_       = nullptr;
    graphics::Quad    *boundQuad_  = nullptr;
    graphics::Renderable2D *boundSprite_ = nullptr;
    float              speed_      = 1.f;
    float              time_       = 0.f;
    int                clipFrame_  = -1;
    bool               playing_    = false;
    bool               paused_     = false;
    bool               finished_   = false;
    bool               loopOverride_ = false;
    bool               loopValue_    = true;
    int                loopCount_    = 0;
    int                pendingLoops_ = 0;
    bool               pendingComplete_ = false;
    std::vector<SpeedKey> speedCurve_;
    float              speedCurveTime_ = 0.f;
    bool               speedCurveLoop_ = true;
    std::string        speedCurveInterpolation_ = "linear";
    SpriteClip        *queuedClip_ = nullptr;
    std::string        pendingEvent_;
    eve::SimulationTick     lastTick_    = eve::SimulationTick::zero();
    bool                    hasLastTick_ = false;
 
    bool updateUnchecked(float dt);
};
 
}  // namespace eve::animation