fill_gradient() [4/4]

template<typename T>

void fill_gradient	(	T *	targetArray,
		uint16_t	startpos,
		CHSV	startcolor,
		uint16_t	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 189 of file colorutils.h.

{
    // if the points are in the wrong order, straighten them
    if( endpos < startpos ) {
        uint16_t 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;
 
    uint8_t 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 = (uint8_t)(256 - huedelta8) << 7;
        huedistance87 = -huedistance87;
    }
 
    uint16_t pixeldistance = endpos - startpos;
    int16_t divisor = pixeldistance ? pixeldistance : 1;
    
    #if FASTLED_USE_32_BIT_GRADIENT_FILL
    // Use higher precision 32 bit math for new micros.
    int32_t huedelta823 = (huedistance87 * 65536) / divisor;
    int32_t satdelta823 = (satdistance87 * 65536) / divisor;
    int32_t valdelta823 = (valdistance87 * 65536) / divisor;
 
    huedelta823 *= 2;
    satdelta823 *= 2;
    valdelta823 *= 2;
    uint32_t hue824 = static_cast<uint32_t>(startcolor.hue) << 24;
    uint32_t sat824 = static_cast<uint32_t>(startcolor.sat) << 24;
    uint32_t val824 = static_cast<uint32_t>(startcolor.val) << 24;
    for( uint16_t 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( uint16_t i = startpos; i <= endpos; ++i) {
        targetArray[i] = CHSV( hue88 >> 8, sat88 >> 8, val88 >> 8);
        hue88 += huedelta87;
        sat88 += satdelta87;
        val88 += valdelta87;
    }
    #endif  // defined(__AVR__)
}

References BACKWARD_HUES, FORWARD_HUES, LONGEST_HUES, saccum87, and SHORTEST_HUES.

Referenced by CHSVPalette16::CHSVPalette16(), CHSVPalette16::CHSVPalette16(), CHSVPalette16::CHSVPalette16(), CHSVPalette256::CHSVPalette256(), CHSVPalette256::CHSVPalette256(), CHSVPalette256::CHSVPalette256(), CHSVPalette32::CHSVPalette32(), CHSVPalette32::CHSVPalette32(), CHSVPalette32::CHSVPalette32(), CRGBPalette16::CRGBPalette16(), CRGBPalette16::CRGBPalette16(), CRGBPalette16::CRGBPalette16(), CRGBPalette256::CRGBPalette256(), CRGBPalette256::CRGBPalette256(), CRGBPalette256::CRGBPalette256(), CRGBPalette32::CRGBPalette32(), CRGBPalette32::CRGBPalette32(), CRGBPalette32::CRGBPalette32(), fill_gradient(), fill_gradient(), and fill_gradient().

Here is the caller graph for this function: