cled_controller.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
 
 
#include "FastLED.h"
#include "led_sysdefs.h"
#include "pixeltypes.h"
#include "color.h"
 
#include "fl/force_inline.h"
#include "pixel_controller.h"
#include "dither_mode.h"
#include "pixel_iterator.h"
#include "fl/engine_events.h"
#include "fl/screenmap.h"
#include "fl/virtual_if_not_avr.h"
 
FASTLED_NAMESPACE_BEGIN
 
 
//
// LED Controller interface definition
//
 
class CLEDController {
protected:
    friend class CFastLED;
    CRGB *m_Data;              
    CLEDController *m_pNext;   
    CRGB m_ColorCorrection;    
    CRGB m_ColorTemperature;   
    EDitherMode m_DitherMode;  
    bool m_enabled = true;
    int m_nLeds;               
    static CLEDController *m_pHead;  
    static CLEDController *m_pTail;  
 
 
    virtual void showColor(const CRGB & data, int nLeds, uint8_t brightness) = 0;
 
    virtual void show(const struct CRGB *data, int nLeds, uint8_t brightness) = 0;
 
public:
 
    Rgbw mRgbMode = RgbwInvalid::value();
    CLEDController& setRgbw(const Rgbw& arg = RgbwDefault::value()) {
        // Note that at this time (Sept 13th, 2024) this is only implemented in the ESP32 driver
        // directly. For an emulated version please see RGBWEmulatedController in chipsets.h
        mRgbMode = arg;
        return *this;  // builder pattern.
    }
 
    void setEnabled(bool enabled) { m_enabled = enabled; }
 
    CLEDController();
    #if defined(FASTLED_TESTING)
    // Silences the warning about the destructor not being virtual during testing.
    // Testing shows that this virtual destructor adds a 600 bytes to the binary on
    // attiny85 and about 1k for the teensy 4.X series.
    // Attiny85:
    //   With CLEDController destructor virtual: 11018 bytes to binary.
    //   Without CLEDController destructor virtual: 10666 bytes to binary.
    // Looking at the ELF/Map file, it appears that adding a virtual destructor to this
    // base class not only adds vtables to the subclasses, but also pulls in malloc & free,
    // which are by far the largest functions in binary size.
    // Since we don't control how this library is compiled, the only thing we can do is
    // carefully enable this virtual destructor for testing only and in the future, for boards
    // that have enough space to handle the extra binary size.
    virtual ~CLEDController();
    #else
    ~CLEDController();
    #endif
    Rgbw getRgbw() const { return mRgbMode; }
 
 
 
    virtual void init() = 0;
 
    VIRTUAL_IF_NOT_AVR void clearLeds(int nLeds = -1) {
        clearLedDataInternal(nLeds);
        showLeds(0);
    }
 
    // Compatibility with the 3.8.x codebase.
    VIRTUAL_IF_NOT_AVR void showLeds(uint8_t brightness) {
        void* data = beginShowLeds();
        showLedsInternal(brightness);
        endShowLeds(data);
    }
 
    ColorAdjustment getAdjustmentData(uint8_t brightness);
 
    void showInternal(const struct CRGB *data, int nLeds, uint8_t brightness) {
        if (m_enabled) {
           show(data, nLeds,brightness);
        }
    }
 
    void showColorInternal(const struct CRGB &data, int nLeds, uint8_t brightness) {
        if (m_enabled) {
            showColor(data, nLeds, brightness);
        }
    }
 
    void showLedsInternal(uint8_t brightness) {
        if (m_enabled) {
            show(m_Data, m_nLeds, brightness);
        }
    }
 
    void showColorInternal(const struct CRGB & data, uint8_t brightness) {
        if (m_enabled) {
            showColor(data, m_nLeds, brightness);
        }
    }
 
    static CLEDController *head() { return m_pHead; }
 
    CLEDController *next() { return m_pNext; }
 
    CLEDController & setLeds(CRGB *data, int nLeds) {
        m_Data = data;
        m_nLeds = nLeds;
        return *this;
    }
 
    void clearLedDataInternal(int nLeds = -1);
 
    virtual int size() { return m_nLeds; }
 
    virtual int lanes() { return 1; }
 
    CRGB* leds() { return m_Data; }
 
    CRGB &operator[](int x) { return m_Data[x]; }
 
    inline CLEDController & setDither(uint8_t ditherMode = BINARY_DITHER) { m_DitherMode = ditherMode; return *this; }
 
    CLEDController& setScreenMap(const fl::XYMap& map) {
        // EngineEvents::onCanvasUiSet(this, map);
        fl::ScreenMap screenmap = map.toScreenMap();
        fl::EngineEvents::onCanvasUiSet(this, screenmap);
        return *this;
    }
 
    CLEDController& setScreenMap(const fl::ScreenMap& map) {
        fl::EngineEvents::onCanvasUiSet(this, map);
        return *this;
    }
 
    CLEDController& setScreenMap(uint16_t width, uint16_t height) {
        return setScreenMap(fl::XYMap::constructRectangularGrid(width, height));
    }
 
    inline uint8_t getDither() { return m_DitherMode; }
 
    virtual void* beginShowLeds() {
        // By default, emit an integer. This integer will, by default, be passed back.
        // If you override beginShowLeds() then
        // you should also override endShowLeds() to match the return state.
        //
        // For async led controllers this should be used as a sync point to block
        // the caller until the leds from the last draw frame have completed drawing.
        // for each controller:
        //   beginShowLeds();
        // for each controller:
        //   showLeds();
        // for each controller:
        //   endShowLeds();
        uintptr_t d = getDither();
        void* out = reinterpret_cast<void*>(d);
        return out;
    }
    virtual void endShowLeds(void* data) {
        // By default recieves the integer that beginShowLeds() emitted.
        //For async controllers this should be used to signal the controller
        // to begin transmitting the current frame to the leds.
        uintptr_t d = reinterpret_cast<uintptr_t>(data);
        setDither(static_cast<uint8_t>(d));
    }
 
    CLEDController & setCorrection(CRGB correction) { m_ColorCorrection = correction; return *this; }
 
    CLEDController & setCorrection(LEDColorCorrection correction) { m_ColorCorrection = correction; return *this; }
 
    CRGB getCorrection() { return m_ColorCorrection; }
 
    CLEDController & setTemperature(CRGB temperature) { m_ColorTemperature = temperature; return *this; }
 
    CLEDController & setTemperature(ColorTemperature temperature) { m_ColorTemperature = temperature; return *this; }
 
    CRGB getTemperature() { return m_ColorTemperature; }
 
    CRGB getAdjustment(uint8_t scale) {
        return CRGB::computeAdjustment(scale, m_ColorCorrection, m_ColorTemperature);
    }
 
    virtual uint16_t getMaxRefreshRate() const { return 0; }
};
 
FASTLED_NAMESPACE_END