CanvasAnim.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>

 
namespace cdc::ui::anim {

enum : uint8_t {
    EASE_LINEAR       = 0,
    EASE_QUAD_IN      = 1,
    EASE_QUAD_OUT     = 2,
    EASE_QUAD_IN_OUT  = 3,
    EASE_CUBIC_IN     = 4,
    EASE_CUBIC_OUT    = 5,
    EASE_CUBIC_IN_OUT = 6,
    EASE_OVERSHOOT    = 7,
    EASE_BOUNCE       = 8,
    EASE_STEP         = 9,
    EASE_ELASTIC      = 10,
    EASE_COUNT        = 11,
};

enum : uint8_t {
    FLAG_FROM_CURRENT = 0x01,  
    FLAG_YOYO         = 0x02,  
    FLAG_HIDE_DONE    = 0x04,  
    FLAG_SHOW_START   = 0x08,  
};

enum : int8_t {
    STATE_DELAYED = 0,
    STATE_RUNNING = 1,
    STATE_PAUSED  = 2,
};

enum : uint8_t {
    SPRITE_ONCE      = 0,  
    SPRITE_LOOP      = 1,
    SPRITE_PING_PONG = 2,
};

enum : uint8_t {
    SPRITE_FLAG_OPAQUE = 0x01,  
    SPRITE_FLAG_FLIP_H = 0x02,
    SPRITE_FLAG_FLIP_V = 0x04,
    SPRITE_FLAG_ROT_90 = 0x08,  
};

constexpr uint16_t REPEAT_FOREVER = 0xFFFF;

struct Completion {
    uint32_t doneActionId = 0;
    uint32_t handle       = 0;  
    uint32_t refId        = 0;  
};

class AnimTarget {
public:
    virtual ~AnimTarget() = default;
    virtual bool getElemOffset(uint32_t elemId, int16_t* ox, int16_t* oy) = 0;
    virtual bool setElemOffset(uint32_t elemId, int16_t ox, int16_t oy)   = 0;
    virtual bool setElemVisible(uint32_t elemId, bool visible)            = 0;
};

int32_t ease(uint8_t curve, int32_t t);

struct TweenConfig {
    uint32_t elemId       = 0;
    int16_t  fromX        = 0;
    int16_t  fromY        = 0;
    int16_t  toX          = 0;
    int16_t  toY          = 0;
    uint16_t durationMs   = 0;
    uint16_t delayMs      = 0;
    uint16_t repeat       = 0;  
    uint8_t  easing       = EASE_LINEAR;
    uint8_t  flags        = 0;
    uint32_t doneActionId = 0;
    uint32_t startAfter   = 0;  
};

class CanvasAnimator {
public:
    static constexpr uint8_t  MAX_TWEENS      = 16;
    static constexpr uint16_t MAX_DURATION_MS = 60000;

    uint32_t start(const TweenConfig& cfg, uint32_t nowMs);

    uint32_t blink(uint32_t elemId, uint16_t periodMs, uint16_t count,
                   uint32_t doneActionId, uint32_t nowMs);

    bool cancel(uint32_t handle);
    void cancelForElem(uint32_t elemId);
    bool pause(uint32_t handle, bool paused, uint32_t nowMs);
    int8_t state(uint32_t handle) const;
    uint8_t activeCount() const;
    void shiftTime(uint32_t deltaMs);
    void reset();

    bool advance(uint32_t nowMs, AnimTarget& target,
                 Completion* done, uint8_t doneCap, uint8_t* doneCount);
 
private:
    enum class Kind : uint8_t { Move, Blink };
    enum class Phase : uint8_t { Free, Chained, Delayed, Running };
 
    struct Slot {
        uint32_t handle       = 0;
        uint32_t elemId       = 0;
        uint32_t doneActionId = 0;
        uint32_t startAfter   = 0;   // predecessor handle while Chained
        uint32_t startMs      = 0;   // run start (delay already applied)
        int16_t  fromX = 0, fromY = 0, toX = 0, toY = 0;
        uint16_t durationMs   = 0;
        uint16_t delayMs      = 0;
        uint16_t remaining    = 0;   // remaining extra runs
        uint16_t blinkCount   = 0;   // remaining blink phases (Kind::Blink)
        uint32_t pausedAtMs   = 0;
        uint8_t  easing       = EASE_LINEAR;
        uint8_t  flags        = 0;
        int16_t  lastX = 0, lastY = 0;  // last offset written to the target
        Kind     kind         = Kind::Move;
        Phase    phase        = Phase::Free;
        bool     paused       = false;
        bool     reversed     = false;  // current yoyo direction / blink phase
        bool     started      = false;  // FROM_CURRENT/SHOW_START applied
        bool     hasLast      = false;
        bool     moved        = false;  // wrote a visible change this tick
    };
 
    Slot*       findSlot(uint32_t handle);
    const Slot* findSlot(uint32_t handle) const;
    Slot*       allocSlot();
    void        releaseChain(uint32_t handle);
    void        finishSlot(Slot& s, AnimTarget& target, uint32_t nowMs,
                           Completion* done, uint8_t doneCap, uint8_t* doneCount);
    bool        advanceMove(Slot& s, uint32_t nowMs, AnimTarget& target);
    bool        advanceBlink(Slot& s, uint32_t nowMs, AnimTarget& target);
    bool        writeOffset(Slot& s, AnimTarget& target, int16_t x, int16_t y);
 
    Slot     slots_[MAX_TWEENS];
    uint32_t nextHandle_ = 1;
};

class SpriteStore {
public:
    static constexpr uint8_t  MAX_SPRITES = 8;
    static constexpr uint16_t MAX_FRAMES  = 32;

    void setArena(uint8_t* buf, uint32_t cap);
    bool hasArena() const { return arena_ != nullptr; }

    int32_t create(uint16_t w, uint16_t h, uint16_t frameCount,
                   const uint8_t* data, uint32_t len);
    bool setMask(uint32_t handle, const uint8_t* mask, uint32_t len);
    bool setFrameDurations(uint32_t handle, const uint16_t* ms, uint16_t count);
    bool destroy(uint32_t handle);
 
    bool setFlags(uint32_t handle, uint8_t flags);
    bool setScale(uint32_t handle, uint8_t scale);
    bool setFrame(uint32_t handle, uint16_t frame);
    int32_t frame(uint32_t handle) const;  

    bool scroll(uint32_t handle, uint16_t windowW, uint16_t stepPx,
                uint16_t gapPx, uint16_t frameMs, uint32_t nowMs);
 
    bool play(uint32_t handle, uint8_t mode, uint16_t frameMs, uint16_t repeat,
              uint32_t doneActionId, uint32_t nowMs);
    bool stop(uint32_t handle);
    void stopAll();
    bool anyPlaying() const;
    void shiftTime(uint32_t deltaMs);
    void reset();

    bool advance(uint32_t nowMs, Completion* done, uint8_t doneCap,
                 uint8_t* doneCount);

    struct FrameView {
        const uint8_t* data = nullptr;  
        const uint8_t* mask = nullptr;  
        uint16_t w = 0, h = 0;
        uint8_t  flags = 0;
        uint8_t  scale = 1;
        uint16_t scrollX = 0;   
        uint16_t scrollWindow = 0;  
        uint16_t scrollGap = 0;     
    };
    bool frameView(uint32_t handle, FrameView* out) const;
 
private:
    struct Slot {
        uint32_t handle       = 0;   // 0 = free
        uint32_t sheetOff     = 0;
        uint32_t maskOff      = 0;
        uint32_t durOff       = 0;
        uint32_t bytes        = 0;   // arena bytes at sheetOff (sheet only)
        uint32_t doneActionId = 0;
        uint32_t nextFrameAt  = 0;
        uint16_t w = 0, h = 0;
        uint16_t frameCount   = 0;
        uint16_t curFrame     = 0;
        uint16_t frameMs      = 0;
        uint16_t remaining    = 0;   // remaining extra cycles
        uint16_t scrollX      = 0;   // marquee position
        uint16_t scrollWindow = 0;   // marquee window width (0 = frames mode)
        uint16_t scrollStep   = 0;   // px per beat
        uint16_t scrollGap    = 0;   // blank px between wraps
        uint8_t  mode         = SPRITE_ONCE;
        uint8_t  flags        = 0;
        uint8_t  scale        = 1;
        bool     playing      = false;
        bool     hasMask      = false;
        bool     hasDur       = false;
        int8_t   dir          = 1;   // ping-pong direction
    };
 
    Slot*       findSlot(uint32_t handle);
    const Slot* findSlot(uint32_t handle) const;
    uint32_t    frameBytes(const Slot& s) const;
    uint16_t    frameDuration(const Slot& s) const;
    int32_t     arenaAlloc(uint32_t bytes);
    void        arenaFree(uint32_t off, uint32_t bytes);
 
    Slot     slots_[MAX_SPRITES];
    uint8_t* arena_      = nullptr;
    uint32_t arenaCap_   = 0;
    uint32_t arenaUsed_  = 0;
    uint32_t nextHandle_ = 1;
};
 
}  // namespace cdc::ui::anim