ColorFromPalette() [1/8]

CHSV fl::ColorFromPalette	(	const CHSVPalette16 &	pal,
		uint8_t	index,
		uint8_t	brightness,
		TBlendType	blendType )

Definition at line 771 of file colorutils.cpp.

                                                                {
    if (blendType == LINEARBLEND_NOWRAP) {
        index = map8(index, 0, 239); // Blend range is affected by lo4 blend of
                                     // values, remap to avoid wrapping
    }
 
    //      hi4 = index >> 4;
    uint8_t hi4 = lsrX4(index);
    uint8_t lo4 = index & 0x0F;
 
    //  CRGB rgb1 = pal[ hi4];
    const CHSV *entry = &(pal[0]) + hi4;
 
    uint8_t hue1 = entry->hue;
    uint8_t sat1 = entry->sat;
    uint8_t val1 = entry->val;
 
    uint8_t blend = lo4 && (blendType != NOBLEND);
 
    if (blend) {
 
        if (hi4 == 15) {
            entry = &(pal[0]);
        } else {
            ++entry;
        }
 
        uint8_t f2 = lo4 << 4;
        uint8_t f1 = 255 - f2;
 
        uint8_t hue2 = entry->hue;
        uint8_t sat2 = entry->sat;
        uint8_t val2 = entry->val;
 
        // Now some special casing for blending to or from
        // either black or white.  Black and white don't have
        // proper 'hue' of their own, so when ramping from
        // something else to/from black/white, we set the 'hue'
        // of the black/white color to be the same as the hue
        // of the other color, so that you get the expected
        // brightness or saturation ramp, with hue staying
        // constant:
 
        // If we are starting from white (sat=0)
        // or black (val=0), adopt the target hue.
        if (sat1 == 0 || val1 == 0) {
            hue1 = hue2;
        }
 
        // If we are ending at white (sat=0)
        // or black (val=0), adopt the starting hue.
        if (sat2 == 0 || val2 == 0) {
            hue2 = hue1;
        }
 
        sat1 = scale8_LEAVING_R1_DIRTY(sat1, f1);
        val1 = scale8_LEAVING_R1_DIRTY(val1, f1);
 
        sat2 = scale8_LEAVING_R1_DIRTY(sat2, f2);
        val2 = scale8_LEAVING_R1_DIRTY(val2, f2);
 
        //    cleanup_R1();
 
        // These sums can't overflow, so no qadd8 needed.
        sat1 += sat2;
        val1 += val2;
 
        uint8_t deltaHue = (uint8_t)(hue2 - hue1);
        if (deltaHue & 0x80) {
            // go backwards
            hue1 -= scale8(256 - deltaHue, f2);
        } else {
            // go forwards
            hue1 += scale8(deltaHue, f2);
        }
 
        cleanup_R1();
    }
 
    if (brightness != 255) {
        val1 = scale8_video(val1, brightness);
    }
 
    return CHSV(hue1, sat1, val1);
}

References blend(), brightness, cleanup_R1(), lsrX4(), map8(), scale8(), scale8_LEAVING_R1_DIRTY(), and scale8_video().

Here is the call graph for this function: