SWTOR: extract from shader code for hueing Garment materials

// ===================================================================================
// HUEING
// ===================================================================================
//Utility Functions
float3 ExpandHSL(in float3 HSL)
{
    //float3 outputVal = inVal * (maxVal - minVal) + minVal;
    float3 expanded = HSL;
    expanded.r = (HSL.r * (.706 - .3137)) + .3137; //reexpand hue
    expanded.r -= .41176; //offset hue
    expanded.g = (HSL.g * .5882);
    expanded.b = (HSL.b * .70588);
    return expanded;
}

float3 AdjustLightness(in float3 HSL, float brightness, float contrast) //Adjust the lightness of the HSL
{
    HSL.b = pow(HSL.b, contrast) * contrast;
    HSL.b = brightness + ((1 - brightness) * HSL.b);
    return HSL;
}

float OffsetHue(in float hue, float hueOffset)
{
    float H = frac(hue + hueOffset);
    return H;
}
float OffsetSaturation(in float saturation, float satOffset)
{
    float S = saturation;
    S = pow(S, satOffset);
    S = S * (1 - satOffset);
    S = saturate(S);
    return S;
}

float3 OffsetHSL(in float3 HSL, float hueOffset, float satOffset)
{
    float H = OffsetHue(HSL.x, hueOffset);
    float S = OffsetSaturation(HSL.y, satOffset);

    return float3(H, S, HSL.z);
}

float3 ConvertHSLToRGB(in float3 HSL)
{
    const float fOneThird = 0.333333333f;
    const float fTwoThirds = 0.666666666f;
    float3 color;

    float temp1, temp2;
    float H = HSL.r;
    float S = HSL.g;
    float L = HSL.b;

    //if (S == 0)
    //  return float3(L, L, L);

    float LtimesS = L*S;

    if (L<0.5f)
        temp2 = L + LtimesS;
    else
        temp2 = L + S - LtimesS;

    temp1 = 2.0f*L-temp2;

    float3 temp3 = frac(float3(H+fOneThird, H, H-fOneThird));

    float3 temp3Times6 = 6.0f * temp3;
    float3 temp3Times2 = 2.0f * temp3;
    float3 temp3Times1point5 = 1.5f * temp3;
    float3 firstEquation = temp1+(temp2-temp1)*6.0f*temp3;
    float3 secondEquation = temp1+(temp2-temp1)*(fTwoThirds-temp3)*6.0f;

    if (temp3Times6.r < 1.0f)
        color.r = firstEquation.r;
    else if (temp3Times2.r < 1.0f)
        color.r = temp2;
    else if (temp3Times1point5.r < 1.0f)
        color.r = secondEquation.r;
    else
        color.r = temp1;

    if (temp3Times6.g < 1.0f)
        color.g = firstEquation.g;
    else if (temp3Times2.g < 1.0f)
        color.g = temp2;
    else if (temp3Times1point5.g < 1.0f)
        color.g = secondEquation.g;
    else
        color.g = temp1;

    if (temp3Times6.b < 1.0f)
        color.b = firstEquation.b;
    else if (temp3Times2.b < 1.0f)
        color.b = temp2;
    else if (temp3Times1point5.b < 1.0f)
        color.b = secondEquation.b;
    else
        color.b = temp1;

    return color;
}



float3 ManipulateHSL(in float3 HSL, float4 palette)
{
    HSL = ExpandHSL(HSL);
    HSL = AdjustLightness(HSL, palette.z, palette.w);
    HSL = OffsetHSL(HSL.rgb, palette.x, palette.y);
    return HSL;
}

float ManipulateAO(in float ao, float brightness, float contrast)
{
    brightness += 1;
    //brightness + ((1 - brightness) * HSL.b);
    float ret = ao * (brightness + (1 - brightness) * ao);
    return saturate(ret);
}


void HuePixel(
    in float4 diffuseMapValue,
    in float4 specularMapValue,
    float4 paletteMaskMapValue,
    float4 paletteMapValue,
    out float3 fragmentDiffuseColor,
    out float4 fragmentSpecularColor
    )
{
    fragmentDiffuseColor = diffuseMapValue.rgb;
    fragmentSpecularColor = specularMapValue;

    float paletteMaskSum = paletteMaskMapValue.x + paletteMaskMapValue.y;


    // Only use the palette that applies
    float4 palette;
    float3 chosenSpecColor, chosenMetallicSpecColor;

    if (paletteMaskMapValue.x < paletteMaskMapValue.y)
        {
            palette = palette2;
            chosenSpecColor = palette2Specular.rgb;
            chosenMetallicSpecColor = palette2MetallicSpecular.rgb;
        }
        else
        {
            palette = palette1;
            chosenSpecColor = palette1Specular.rgb;
            chosenMetallicSpecColor = palette1MetallicSpecular.rgb;
        }

        // Get the palette map, apply the deltas, and convert it to RGB
        float3 HSL = ManipulateHSL(float3(paletteMapValue.g, paletteMapValue.b, paletteMapValue.a), palette);
        float ambientOcclusion = ManipulateAO(paletteMapValue.r, palette.z, palette.w);
        HSL.z *= ambientOcclusion;
        float3 RGB = ConvertHSLToRGB(HSL);

        //Blend the result into the original diffuse
        fragmentDiffuseColor = lerp(diffuseMapValue.rgb, RGB.rgb, paletteMaskSum);

        // Determine the hue specular color
        float3 hueSpecColor;
        const float3 white = float3(1,1,1);
        float metallicMask = paletteMaskMapValue.b;
        //1.0 uses chosenMetallicSpecColor, .5 uses white, 0.0 uses chosenSpecColor
        if( metallicMask > .5 )
        {
            hueSpecColor = lerp(white, chosenMetallicSpecColor, (metallicMask - 0.5) * 2);
        }
        else
        {
            hueSpecColor = lerp(chosenSpecColor, white, metallicMask * 2);
        }
        hueSpecColor *= specularMapValue.r;
        fragmentSpecularColor.rgb = lerp(fragmentSpecularColor.rgb, hueSpecColor, paletteMaskSum);

}