How to fade in/out each LED to/from a different hue?

[ghost]

I have a chain of 100 WS2812 LED.
With this code I create a "rainbow" effect along the whole chain:

NeoPixelBus<NeoGrbFeature, NeoEsp32I2s1Ws2812xMethod> _strip; 
#define LED_SIZE 100

float lum = 0.5;
for (int i = 1; i < LED_SIZE; i++) _strip()->SetPixelColor(i, HslColor((float) i / LED_SIZE , 1.0, lum));

Now, say I want to fade from off (lum = 0) to the target lum, where each LED has the above target hue.
And, viceversa, fade to off the chain.

From my understanding I should use 100 AnimationState, since each one should be initialized with the correct hue.
Is it correct or is there a smarter way to do this with a good LinearBlend implementation?

[ghost]

With the 100 animations it works:

NeoPixelBus<NeoGrbFeature, NeoEsp32I2s1Ws2812xMethod> strip;
NeoPixelAnimator _animation(LED_SIZE, NEO_DECISECONDS);
AnimationState _animationState[100];

for (int i = 0; i < 100; i++)
{
    _animationState[i].StartingColor = _animationState[i].CurrentColor;
    _animationState[i].EndingColor = HslColor((float) i / _length , 1.0, 0.5);
    _animation.StartAnimation(i, duration, [this](const AnimationParam &param)
    {
        int j = param.index;

        HslColor updatedColor = HslColor::LinearBlend<NeoHueBlendShortestDistance>(_animationState[j].StartingColor, _animationState[j].EndingColor, param.progress);
        
        this->_animationState[j].CurrentColor = updatedColor;
        strip.SetPixelColor(j, updatedColor); 
    });
}

Is it ok, or is there anything better that does not requires 100 animations?

[Makuna]

Animations state is better used for multiple animations than a single one. Sometimes it's not even useful.

The Wiki Page for Animations

Always first understand and describe your animations (to yourself/comments in code). Sounds like a funny thing, but it keeps you straight on what you want and makes it clear when you ask for help. I am going to do that based on what I see your code above is attempting.

// render a color wheel/rainbow across the complete strip and animate it moving slowly to the right
// continue to do this for ever

each animation only needs one animation channel usually. Think of channels as timelines for the animation, and if it all fits in one timeline, use only one animation channel. What you describe only needs one.

NeoPixelAnimator _animation(1, NEO_DECISECONDS);

Then start your specific animation passing the animation update routine (in your case a lambda)

    _animation.StartAnimation(0, duration, [this](const AnimationParam &param)
    {
        float hue;  

        // set all pixels with a hue that increments across the pixels for the rainbow
        // and also uses time/progress in the animation to further modify the hue
        // param.progress will start at 0.0 and end at 1.0, hue is also 0.0 to 1.0, convenient
        for (int pixel = 0; pixel < strip.PixelCount(); pixel++)
        {
            hue = static_cast<float>(pixel) / strip.PixelCount() + param.progress; // subtract progress to animate to the left
            // while not required, its best to keep hue within 0.0-1.0
            if (hue > 1.0f)
            {
                hue -= 1.0f;
            }
            else if (hue < 0.0f)
            {
               hue += 1.0f;
            }
            strip.SetPixelColor(pixel, HslColor(hue, 1.0f, 0.5f));
        }
        // since we want to continue forever, check if its complete and restart it
        if (param.state == AnimationState_Completed)
        {
            _animation.RestartAnimation(0);
        }
    });