fill_gradient()

template<typename T>

void fl::fill_gradient	(	T *	targetArray,
		u16	startpos,
		CHSV	startcolor,
		u16	endpos,
		CHSV	endcolor,
		TGradientDirectionCode	directionCode = SHORTEST_HUES )

Fill a range of LEDs with a smooth HSV gradient between two HSV colors.

This function can write the gradient colors either:

1. Into an array of CRGBs (e.g., an leds[] array, or a CRGB palette)
2. Into an array of CHSVs (e.g. a CHSV palette).

In the case of writing into a CRGB array, the gradient is computed in HSV space, and then HSV values are converted to RGB as they're written into the CRGB array.

Parameters

targetArray	a pointer to the color array to fill
startpos	the starting position in the array
startcolor	the starting color for the gradient
endpos	the ending position in the array
endcolor	the end color for the gradient
directionCode	the direction to travel around the color wheel

Definition at line 105 of file fill.h.

                                                                                     {
    // if the points are in the wrong order, straighten them
    if (endpos < startpos) {
        u16 t = endpos;
        CHSV tc = endcolor;
        endcolor = startcolor;
        endpos = startpos;
        startpos = t;
        startcolor = tc;
    }
 
    // If we're fading toward black (val=0) or white (sat=0),
    // then set the endhue to the starthue.
    // This lets us ramp smoothly to black or white, regardless
    // of what 'hue' was set in the endcolor (since it doesn't matter)
    if (endcolor.value == 0 || endcolor.saturation == 0) {
        endcolor.hue = startcolor.hue;
    }
 
    // Similarly, if we're fading in from black (val=0) or white (sat=0)
    // then set the starthue to the endhue.
    // This lets us ramp smoothly up from black or white, regardless
    // of what 'hue' was set in the startcolor (since it doesn't matter)
    if (startcolor.value == 0 || startcolor.saturation == 0) {
        startcolor.hue = endcolor.hue;
    }
 
    saccum87 huedistance87;
    saccum87 satdistance87;
    saccum87 valdistance87;
 
    satdistance87 = (endcolor.sat - startcolor.sat) << 7;
    valdistance87 = (endcolor.val - startcolor.val) << 7;
 
    fl::u8 huedelta8 = endcolor.hue - startcolor.hue;
 
    if (directionCode == SHORTEST_HUES) {
        directionCode = FORWARD_HUES;
        if (huedelta8 > 127) {
            directionCode = BACKWARD_HUES;
        }
    }
 
    if (directionCode == LONGEST_HUES) {
        directionCode = FORWARD_HUES;
        if (huedelta8 < 128) {
            directionCode = BACKWARD_HUES;
        }
    }
 
    if (directionCode == FORWARD_HUES) {
        huedistance87 = huedelta8 << 7;
    } else /* directionCode == BACKWARD_HUES */
    {
        huedistance87 = (fl::u8)(256 - huedelta8) << 7;
        huedistance87 = -huedistance87;
    }
 
    u16 pixeldistance = endpos - startpos;
    i16 divisor = pixeldistance ? pixeldistance : 1;
 
#if FASTLED_USE_32_BIT_GRADIENT_FILL
    // Use higher precision 32 bit math for new micros.
    i32 huedelta823 = (huedistance87 * 65536) / divisor;
    i32 satdelta823 = (satdistance87 * 65536) / divisor;
    i32 valdelta823 = (valdistance87 * 65536) / divisor;
 
    huedelta823 *= 2;
    satdelta823 *= 2;
    valdelta823 *= 2;
    u32 hue824 = static_cast<u32>(startcolor.hue) << 24;
    u32 sat824 = static_cast<u32>(startcolor.sat) << 24;
    u32 val824 = static_cast<u32>(startcolor.val) << 24;
    for (u16 i = startpos; i <= endpos; ++i) {
        targetArray[i] = CHSV(hue824 >> 24, sat824 >> 24, val824 >> 24);
        hue824 += huedelta823;
        sat824 += satdelta823;
        val824 += valdelta823;
    }
#else
    // Use 8-bit math for older micros.
    saccum87 huedelta87 = huedistance87 / divisor;
    saccum87 satdelta87 = satdistance87 / divisor;
    saccum87 valdelta87 = valdistance87 / divisor;
 
    huedelta87 *= 2;
    satdelta87 *= 2;
    valdelta87 *= 2;
 
    accum88 hue88 = startcolor.hue << 8;
    accum88 sat88 = startcolor.sat << 8;
    accum88 val88 = startcolor.val << 8;
    for (u16 i = startpos; i <= endpos; ++i) {
        targetArray[i] = CHSV(hue88 >> 8, sat88 >> 8, val88 >> 8);
        hue88 += huedelta87;
        sat88 += satdelta87;
        val88 += valdelta87;
    }
#endif // defined(FL_IS_AVR)
}

Referenced by FL_DISABLE_WARNING().

Here is the caller graph for this function: