cled_controller.h

#pragma once
 
#include <stddef.h>
 
 
#include "FastLED.h"
#include "led_sysdefs.h"
#include "pixeltypes.h"
#include "color.h"
 
#include "force_inline.h"
#include "pixel_controller.h"
#include "dither_mode.h"
#include "pixel_iterator.h"
#include "engine_events.h"
#include "screenmap.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;  
    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.
    }
    Rgbw getRgbw() const { return mRgbMode; }
 
    CLEDController() : m_Data(NULL), m_ColorCorrection(UncorrectedColor), m_ColorTemperature(UncorrectedTemperature), m_DitherMode(BINARY_DITHER), m_nLeds(0) {
        m_pNext = NULL;
        if(m_pHead==NULL) { m_pHead = this; }
        if(m_pTail != NULL) { m_pTail->m_pNext = this; }
        m_pTail = this;
    }
 
    virtual void init() = 0;
 
    virtual void clearLeds(int nLeds = -1) {
        clearLedDataInternal(nLeds);
    }
 
    inline ColorAdjustment getAdjustmentData(uint8_t brightness) {
        // *premixed = getAdjustment(brightness);
        // if (color_correction) {
        //     *color_correction = getAdjustment(255);
        // }
        #if FASTLED_HD_COLOR_MIXING
        ColorAdjustment out = {getAdjustment(brightness), getAdjustment(255), brightness};
        #else
        ColorAdjustment out = {getAdjustment(brightness)};
        #endif
        return out;
    }
 
    void showInternal(const struct CRGB *data, int nLeds, uint8_t brightness) {
        show(data, nLeds,brightness);
    }
 
    void showColorInternal(const struct CRGB &data, int nLeds, uint8_t brightness) {
        showColor(data, nLeds, brightness);
    }
 
    void showLedsInternal(uint8_t brightness) {
        show(m_Data, m_nLeds, brightness);
    }
 
    void showColorInternal(const struct CRGB & data, uint8_t brightness) {
        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) {
        if(m_Data) {
            nLeds = (nLeds < 0) ? m_nLeds : nLeds;
            nLeds = (nLeds > m_nLeds) ? m_nLeds : nLeds;
            memset((void*)m_Data, 0, sizeof(struct CRGB) * nLeds);
        }
    }
 
    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 XYMap& map) {
        // EngineEvents::onCanvasUiSet(this, map);
        ScreenMap screenmap = map.toScreenMap();
        EngineEvents::onCanvasUiSet(this, screenmap);
        return *this;
    }
 
    CLEDController& setScreenMap(const ScreenMap& map) {
        EngineEvents::onCanvasUiSet(this, map);
        return *this;
    }
 
    CLEDController& setScreenMap(uint16_t width, uint16_t height) {
        return setScreenMap(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