fx_engine.h

#pragma once
 
#include <stdint.h>
#include <string.h>
 
 
#include "crgb.h"
#include "fixed_map.h"
#include "fx/fx.h"
#include "fx/detail/fx_compositor.h"
#include "fx/detail/fx_layer.h"
#include "namespace.h"
#include "ref.h"
#include "ui.h"
#include "fx/detail/time_warp.h"
#include "fx/video.h"
 
 
// Forward declaration
class TimeWarp;
 
#ifndef FASTLED_FX_ENGINE_MAX_FX
#define FASTLED_FX_ENGINE_MAX_FX 64
#endif
 
FASTLED_NAMESPACE_BEGIN
 
class FxEngine {
  public:
    typedef FixedMap<int, FxRef, FASTLED_FX_ENGINE_MAX_FX> IntFxMap;
    FxEngine(uint16_t numLeds);
 
    ~FxEngine();
 
    int addFx(FxRef effect);
 
 
    int addVideo(Video video, XYMap xymap);
 
    int addFx(Fx& effect) { return addFx(Ref<Fx>::NoTracking(effect)); }
 
    FxRef removeFx(int index);
 
    FxRef getFx(int index);
 
    int getCurrentFxId() const { return mCurrId; }
 
    bool draw(uint32_t now, CRGB *outputBuffer);
 
    bool nextFx(uint16_t transition_ms = 500);
 
    bool setNextFx(int index, uint16_t duration);
 
    
    IntFxMap& _getEffects() { return mEffects; }
 
    void setTimeScale(float timeScale) { mTimeWarp.setTimeScale(timeScale); }
 
  private:
    Slider mTimeBender;
    int mCounter = 0;
    TimeWarp mTimeWarp;  // FxEngine controls the clock, to allow "time-bending" effects.
    IntFxMap mEffects; 
    FxCompositor mCompositor; 
    int mCurrId; 
    uint16_t mDuration = 0; 
    bool mDurationSet = false; 
};
 
inline FxEngine::FxEngine(uint16_t numLeds)
    : mTimeBender("FxEngineSpeed", 1.0f, -50.0f, 50.0f, 0.01f), 
      mTimeWarp(0), 
      mCompositor(numLeds), 
      mCurrId(0) {
}
 
inline FxEngine::~FxEngine() {}
 
inline int FxEngine::addFx(FxRef effect) {
    bool auto_set = mEffects.empty();
    bool ok = mEffects.insert(mCounter, effect);
    if (!ok) {
        return -1;
    }
    if (auto_set) {
        mCurrId = mCounter;
        mCompositor.startTransition(0, 0, effect);
    }
    return mCounter++;
}
 
int FxEngine::addVideo(Video video, XYMap xymap) {
    auto vidfx = VideoFxRef::New(video, xymap);
    int id = addFx(vidfx);
    return id;
}
 
inline bool FxEngine::nextFx(uint16_t duration) {
    bool ok = mEffects.next(mCurrId, &mCurrId, true);
    if (!ok) {
        return false;
    }
    setNextFx(mCurrId, duration);
    return true;
}
 
inline bool FxEngine::setNextFx(int index, uint16_t duration) {
    if (!mEffects.has(index)) {
        return false;
    }
    mCurrId = index;
    mDuration = duration;
    mDurationSet = true;
    return true;
}
 
inline FxRef FxEngine::removeFx(int index) {
    if (!mEffects.has(index)) {
        return FxRef();
    }
    
    FxRef removedFx;
    bool ok = mEffects.get(index, &removedFx);
    if (!ok) {
        return FxRef();
    }
    
    if (mCurrId == index) {
        // If we're removing the current effect, switch to the next one
        mEffects.next(mCurrId, &mCurrId, true);
        mDurationSet = true;
        mDuration = 0; // Instant transition
    }
    
    return removedFx;
}
 
inline FxRef FxEngine::getFx(int id) {
    if (mEffects.has(id)) {
        FxRef fx;
        mEffects.get(id, &fx);
        return fx;
    }
    return FxRef();
}
 
inline bool FxEngine::draw(uint32_t now, CRGB *finalBuffer) {
    mTimeWarp.setTimeScale(mTimeBender);
    mTimeWarp.update(now);
    uint32_t warpedTime = mTimeWarp.getTime();
 
    if (mEffects.empty()) {
        return false;
    }
    if (mDurationSet) {
        FxRef fx;
        bool ok = mEffects.get(mCurrId, &fx);
        if (!ok) {
            // something went wrong.
            return false;
        }
        mCompositor.startTransition(now, mDuration, fx);
        mDurationSet = false;
    }
    if (!mEffects.empty()) {
        mCompositor.draw(now, warpedTime, finalBuffer);
    }
    return true;
}
 
FASTLED_NAMESPACE_END