ColorFromPalette() [3/8]

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

Definition at line 858 of file colorutils.cpp.

                                                                {
    if (blendType == LINEARBLEND_NOWRAP) {
        index = map8(index, 0, 247); // Blend range is affected by lo3 blend of
                                     // values, remap to avoid wrapping
    }
 
    uint8_t hi5 = index;
#if defined(__AVR__)
    hi5 /= 2;
    hi5 /= 2;
    hi5 /= 2;
#else
    hi5 >>= 3;
#endif
    uint8_t lo3 = index & 0x07;
 
    uint8_t hi5XsizeofCHSV = hi5 * sizeof(CHSV);
    const CHSV *entry = (CHSV *)((uint8_t *)(&(pal[0])) + hi5XsizeofCHSV);
 
    uint8_t hue1 = entry->hue;
    uint8_t sat1 = entry->sat;
    uint8_t val1 = entry->val;
 
    uint8_t blend = lo3 && (blendType != NOBLEND);
 
    if (blend) {
 
        if (hi5 == 31) {
            entry = &(pal[0]);
        } else {
            ++entry;
        }
 
        uint8_t f2 = lo3 << 5;
        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(), map8(), scale8(), scale8_LEAVING_R1_DIRTY(), and scale8_video().

Here is the call graph for this function: