PixelIterator()

template<typename PixelControllerT>

fl::PixelIterator::PixelIterator ( PixelControllerT * pc, const Rgbw & rgbw, Rgbww rgbww = RgbwwInvalid::value() )

inline

Definition at line 213 of file pixel_iterator.h.

         : mPixelController(pc), mRgbw(rgbw), mRgbww(rgbww) {
      // Manually build up a vtable.
      // Wait... what? Stupid nerds trying to show off how smart they are...
      // Why not just use a virtual function?!
      //
      // Before you think this then you should know that the alternative straight
      // forward way is to have a virtual interface class that PixelController inherits from.
      // ...and that was already tried. And if you try to do this yourself
      // this then let me tell you what is going to happen...
      //
      // EVERY SINGLE PLATFORM THAT HAS A COMPILED BINARY SIZE CHECK WILL IMMEDIATELY
      // FAIL AS THE BINARY BLOWS UP BY 10-30%!!! It doesn't matter if only one PixelController
      // with a vtable is used, gcc seems not to de-virtualize the calls. And we really care
      // about binary size since FastLED needs to run on those tiny little microcontrollers like
      // the Attiny85 (and family) which are in the sub $1 range used for commercial products.
      //
      // So to satisfy these tight memory requirements we make the dynamic dispatch used in PixelIterator
      // an optional zero-cost abstraction which doesn't affect the binary size for platforms that
      // don't use it. So that's why we are using this manual construction of the vtable that is built
      // up using template magic. If your platform has lots of memory then you'll gladly trade
      // a sliver of memory for the convenience of having a concrete implementation of
      // PixelController that you can use without having to make all your driver code a template.
      //
      // Btw, this pattern in C++ is called the "type-erasure pattern". It allows non virtual
      // polymorphism by leveraging the C++ template system to ensure type safety.
      typedef PixelControllerVtable<PixelControllerT> Vtable;
      mLoadAndScaleRGBW = RgbwLoadBinder<PixelControllerT>::ordered();
      mLoadAndScaleRGBWW = RgbwLoadBinder<PixelControllerT>::orderedWW();
      mLoadAndScaleRGBWUnordered = RgbwLoadBinder<PixelControllerT>::unordered();
      mLoadAndScaleRGBWWUnordered = RgbwLoadBinder<PixelControllerT>::unorderedWW();
      mLoadAndScaleRGB = &Vtable::loadAndScaleRGB;
#if !FL_PLATFORM_HAS_TINY_MEMORY
      mLoadAndScaleRGB16 = WideLoadBinder<PixelControllerT>::get();
#endif
      // NOTE: mLoadAndScale_APA102_HD removed - use fl::loadAndScale_APA102_HD<RGB_ORDER>() from apa102.h encoder
      // NOTE: mLoadAndScale_WS2816_HD removed - use fl::loadAndScale_WS2816_HD<RGB_ORDER>() from ws2816.h encoder
      mStepDithering = &Vtable::stepDithering;
      mAdvanceData = &Vtable::advanceData;
      mSize = &Vtable::size;
      mHas = &Vtable::has;
      #if FASTLED_HD_COLOR_MIXING
      mLoadRGBScaleAndBrightness = &Vtable::loadRGBScaleAndBrightness;
      mGetHdScale = &Vtable::getHdScale;
      #endif
    }

References fl::FL_NO_EXCEPT, fl::WideLoadBinder< T, typename >::get(), mAdvanceData, mHas, mLoadAndScaleRGB, mLoadAndScaleRGB16, mLoadAndScaleRGBW, mLoadAndScaleRGBWUnordered, mLoadAndScaleRGBWW, mLoadAndScaleRGBWWUnordered, mPixelController, mRgbw, mRgbww, mSize, mStepDithering, fl::RgbwLoadBinder< T, typename >::ordered(), fl::RgbwLoadBinder< T, typename >::orderedWW(), rgbw, fl::RgbwLoadBinder< T, typename >::unordered(), fl::RgbwLoadBinder< T, typename >::unorderedWW(), and fl::RgbwwInvalid::value().

Here is the call graph for this function: