rgbx_animation.h

Go to the documentation of this file.

 
#ifndef RGBX_ANIMATION_H_
#define RGBX_ANIMATION_H_
 
#ifndef __cplusplus
#error "rgbx_animation.h is the C++ wrapper; C extensions should use rgbx_api.h directly"
#endif
 
#include <rgbx/rgbx_api.h>
#include <zephyr/llext/symbol.h>
 
#include <type_traits>
 
namespace rgbx {
 
class Animation {
   public:
    virtual void init() {}
 
    virtual void tick(uint32_t dt_ms) = 0;
 
    virtual bool goodMoment() const { return true; }
 
   protected:
    /* Non-virtual on purpose: instances are static and never deleted
     * polymorphically, and a virtual destructor would drag in operator
     * delete, which the sandbox does not provide. */
    ~Animation() = default;
 
    size_t width() const { return rgbx_manifest.width; }
    size_t height() const { return rgbx_manifest.height; }
 
    void setPixel(size_t x, size_t y, uint8_t r, uint8_t g, uint8_t b) {
        if (x >= width() || y >= height()) {
            return;
        }
        uint8_t *px = &rgbx_framebuffer[RGBX_PIXEL_INDEX(width(), x, y)];
        px[0] = r;
        px[1] = g;
        px[2] = b;
    }
 
    void fill(uint8_t r, uint8_t g, uint8_t b) {
        const size_t n = width() * height();
        for (size_t i = 0; i < n; i++) {
            uint8_t *px = &rgbx_framebuffer[i * 3u];
            px[0] = r;
            px[1] = g;
            px[2] = b;
        }
    }
 
    /* --- typed parameter accessors (manifest declaration order) ---------- */
 
    uint32_t paramU32(size_t i) const {
        return (i < RGBX_MAX_PARAMS) ? rgbx_inputs.params[i] : 0u;
    }
 
    uint32_t param(size_t i) const { return paramU32(i); }
 
    uint32_t paramColor(size_t i) const { return paramU32(i) & 0x00FFFFFFu; }
 
    bool paramBool(size_t i) const { return paramU32(i) != 0u; }
 
    float paramF32(size_t i) const {
        const uint32_t bits = paramU32(i);
        float value;
        __builtin_memcpy(&value, &bits, sizeof(value));
        return value;
    }
 
    const char *paramString(size_t i) const {
        if (i >= rgbx_manifest.param_count ||
            rgbx_manifest.params[i].type != RGBX_PARAM_STRING) {
            return "";
        }
        size_t slot = 0;
        for (size_t p = 0; p < i; p++) {
            if (rgbx_manifest.params[p].type == RGBX_PARAM_STRING) {
                slot++;
            }
        }
        return (slot < RGBX_MAX_STRING_PARAMS) ? rgbx_inputs.param_strings[slot] : "";
    }
 
    float accelX() const { return rgbx_inputs.accel[0]; }
    float accelY() const { return rgbx_inputs.accel[1]; }
    float accelZ() const { return rgbx_inputs.accel[2]; }
    float gyroX() const { return rgbx_inputs.gyro[0]; }
    float gyroY() const { return rgbx_inputs.gyro[1]; }
    float gyroZ() const { return rgbx_inputs.gyro[2]; }
 
    static constexpr size_t numBands() { return RGBX_AUDIO_NUM_BANDS; }
    float bandEnergy(size_t b) const {
        return (b < RGBX_AUDIO_NUM_BANDS) ? rgbx_inputs.audio_band_energy[b] : 0.0f;
    }
    bool isBeat(size_t b) const {
        return (b < RGBX_AUDIO_NUM_BANDS) && rgbx_inputs.audio_beat[b] != 0u;
    }
    static constexpr size_t numDisplayBuckets() { return RGBX_AUDIO_NUM_DISPLAY_BUCKETS; }
    float displayBucket(size_t i) const {
        return (i < RGBX_AUDIO_NUM_DISPLAY_BUCKETS) ? rgbx_inputs.audio_display_bucket[i]
                                                    : 0.0f;
    }
 
    uint32_t buttonsPressed() const { return rgbx_inputs.buttons_pressed; }
    bool buttonWasPressed(size_t id) const {
        return id < 32 && (rgbx_inputs.buttons_pressed & (1u << id)) != 0u;
    }
 
};
 
}  // namespace rgbx
 
#define RGBX_ANIMATION(ClassName, DisplayName, W, H, ...)                                       \
    static_assert(std::is_trivially_destructible_v<ClassName>,                                  \
                  "extension animation classes must be trivially destructible (no atexit in "  \
                  "the sandbox)");                                                              \
    extern "C" void __cxa_pure_virtual(void) {                                                  \
        while (true) {                                                                          \
        }                                                                                       \
    }                                                                                           \
    /* Definitions below pick up C language linkage from the declarations in rgbx_api.h. */    \
    struct rgbx_inputs rgbx_inputs;                                                             \
    uint8_t rgbx_framebuffer[(size_t)(W) * (size_t)(H) * 3u];                                   \
    __VA_OPT__(static const struct rgbx_param_desc rgbx_wrapper_params_[] = {__VA_ARGS__};)     \
    const struct rgbx_manifest rgbx_manifest = {                                                \
        RGBX_ABI_VERSION,                                                                       \
        (DisplayName),                                                                          \
        (W),                                                                                    \
        (H),                                                                                    \
        0u __VA_OPT__(+sizeof(rgbx_wrapper_params_) / sizeof(rgbx_wrapper_params_[0])),         \
        NULL __VA_OPT__(? NULL : rgbx_wrapper_params_),                                         \
    };                                                                                          \
    static ClassName rgbx_wrapper_instance_;                                                    \
    uint8_t rgbx_good_moment;                                                                   \
    void rgbx_init(void) { rgbx_wrapper_instance_.init(); }                                     \
    void rgbx_tick(void) {                                                                      \
        rgbx_wrapper_instance_.tick(rgbx_inputs.dt_ms);                                         \
        rgbx_good_moment = rgbx_wrapper_instance_.goodMoment() ? 1u : 0u;                       \
    }                                                                                           \
    EXPORT_SYMBOL(rgbx_manifest);                                                               \
    EXPORT_SYMBOL(rgbx_inputs);                                                                 \
    EXPORT_SYMBOL(rgbx_framebuffer);                                                            \
    EXPORT_SYMBOL(rgbx_init);                                                                   \
    EXPORT_SYMBOL(rgbx_tick);                                                                   \
    EXPORT_SYMBOL(rgbx_good_moment)
 
#endif /* RGBX_ANIMATION_H_ */