//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Common pixel shader code
//
// $NoKeywords: $
//
//=============================================================================//
#ifndef COMMON_PS_FXC_H_
#define COMMON_PS_FXC_H_

#include "common_fxc.h"

// Put global skip commands here. . make sure and check that the appropriate
// vars are defined so these aren't used on the wrong shaders!

// --------------------------------------------------------------------------------
// HDR should never be enabled if we don't aren't running in float or integer
// HDR mode. SKIP: defined $HDRTYPE && defined $HDRENABLED && !$HDRTYPE &&
// $HDRENABLED
// --------------------------------------------------------------------------------
// We don't ever write water fog to dest alpha if we aren't doing water fog.
// SKIP: defined $PIXELFOGTYPE && defined $WRITEWATERFOGTODESTALPHA && (
// $PIXELFOGTYPE != 1 ) && $WRITEWATERFOGTODESTALPHA
// --------------------------------------------------------------------------------
// We don't need fog in the pixel shader if we aren't in float fog mode2
// NOSKIP: defined $HDRTYPE && defined $HDRENABLED && defined $PIXELFOGTYPE &&
// $HDRTYPE != HDR_TYPE_FLOAT && $FOGTYPE != 0
// --------------------------------------------------------------------------------
// We don't do HDR and LIGHTING_PREVIEW at the same time since it's running LDR
// in hammer.
//  SKIP: defined $LIGHTING_PREVIEW && defined $HDRTYPE && $LIGHTING_PREVIEW &&
//  $HDRTYPE != 0
// --------------------------------------------------------------------------------
// Ditch all fastpath attempts if we are doing LIGHTING_PREVIEW.
//	SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATHENVMAPTINT &&
//$LIGHTING_PREVIEW && $FASTPATHENVMAPTINT 	SKIP: defined $LIGHTING_PREVIEW &&
//defined $FASTPATHENVMAPCONTRAST && $LIGHTING_PREVIEW &&
//$FASTPATHENVMAPCONTRAST 	SKIP: defined $LIGHTING_PREVIEW && defined $FASTPATH
//&& $LIGHTING_PREVIEW && $FASTPATH
// --------------------------------------------------------------------------------
// Ditch flashlight depth when flashlight is disabled
//  SKIP: ($FLASHLIGHT || $FLASHLIGHTSHADOWS) && $LIGHTING_PREVIEW
// --------------------------------------------------------------------------------

// System defined pixel shader constants

#if defined(_X360)
const bool g_bHighQualityShadows : register(b0);
#endif

// NOTE: w == 1.0f / (Dest alpha compressed depth range).
const float4 g_LinearFogColor : register(c29);
#define OO_DESTALPHA_DEPTH_RANGE (g_LinearFogColor.w)

// Linear and gamma light scale values
const float4 cLightScale : register(c30);
#define LINEAR_LIGHT_SCALE (cLightScale.x)
#define LIGHT_MAP_SCALE (cLightScale.y)
#define ENV_MAP_SCALE (cLightScale.z)
#define GAMMA_LIGHT_SCALE (cLightScale.w)

// Flashlight constants
#if defined(SHADER_MODEL_PS_2_0) || defined(SHADER_MODEL_PS_2_B) || \
    defined(SHADER_MODEL_PS_3_0)
const float4 cFlashlightColor : register(c28);
const float4 cFlashlightScreenScale
    : register(c31);  // .zw are currently unused
#define flFlashlightNoLambertValue \
    cFlashlightColor.w  // This is either 0.0 or 2.0
#endif

#define HDR_INPUT_MAP_SCALE 16.0f

#define TONEMAP_SCALE_NONE 0
#define TONEMAP_SCALE_LINEAR 1
#define TONEMAP_SCALE_GAMMA 2

#define PIXEL_FOG_TYPE_NONE \
    -1  // MATERIAL_FOG_NONE is handled by PIXEL_FOG_TYPE_RANGE, this is for
        // explicitly disabling fog in the shader
#define PIXEL_FOG_TYPE_RANGE \
    0  // range+none packed together in ps2b. Simply none in ps20 (instruction
       // limits)
#define PIXEL_FOG_TYPE_HEIGHT 1

// If you change these, make the corresponding change in hardwareconfig.cpp
#define NVIDIA_PCF_POISSON 0
#define ATI_NOPCF 1
#define ATI_NO_PCF_FETCH4 2

struct LPREVIEW_PS_OUT {
    float4 color : COLOR0;
    float4 normal : COLOR1;
    float4 position : COLOR2;
    float4 flags : COLOR3;
};

/*
// unused
HALF Luminance( HALF3 color )
{
        return dot( color, HALF3( HALF_CONSTANT(0.30f), HALF_CONSTANT(0.59f),
HALF_CONSTANT(0.11f) ) );
}
*/

/*
// unused
HALF LuminanceScaled( HALF3 color )
{
        return dot( color, HALF3( HALF_CONSTANT(0.30f) / MAX_HDR_OVERBRIGHT,
HALF_CONSTANT(0.59f) / MAX_HDR_OVERBRIGHT, HALF_CONSTANT(0.11f) /
MAX_HDR_OVERBRIGHT ) );
}
*/

/*
// unused
HALF AvgColor( HALF3 color )
{
        return dot( color, HALF3( HALF_CONSTANT(0.33333f),
HALF_CONSTANT(0.33333f), HALF_CONSTANT(0.33333f) ) );
}
*/

/*
// unused
HALF4 DiffuseBump( sampler lightmapSampler,
                   float2  lightmapTexCoord1,
                   float2  lightmapTexCoord2,
                   float2  lightmapTexCoord3,
                   HALF3   normal )
{
        HALF3 lightmapColor1 = tex2D( lightmapSampler, lightmapTexCoord1 );
        HALF3 lightmapColor2 = tex2D( lightmapSampler, lightmapTexCoord2 );
        HALF3 lightmapColor3 = tex2D( lightmapSampler, lightmapTexCoord3 );

        HALF3 diffuseLighting;
        diffuseLighting = saturate( dot( normal, bumpBasis[0] ) ) *
lightmapColor1 + saturate( dot( normal, bumpBasis[1] ) ) * lightmapColor2 +
                                          saturate( dot( normal, bumpBasis[2] )
) * lightmapColor3;

        return HALF4( diffuseLighting, LuminanceScaled( diffuseLighting ) );
}
*/

/*
// unused
HALF Fresnel( HALF3 normal,
              HALF3 eye,
              HALF2 scaleBias )
{
        HALF fresnel = HALF_CONSTANT(1.0f) - dot( normal, eye );
        fresnel = pow( fresnel, HALF_CONSTANT(5.0f) );

        return fresnel * scaleBias.x + scaleBias.y;
}
*/

/*
// unused
HALF4 GetNormal( sampler normalSampler,
                 float2 normalTexCoord )
{
        HALF4 normal = tex2D( normalSampler, normalTexCoord );
        normal.rgb = HALF_CONSTANT(2.0f) * normal.rgb - HALF_CONSTANT(1.0f);

        return normal;
}
*/

// Needs to match NormalDecodeMode_t enum in imaterialsystem.h
#define NORM_DECODE_NONE 0
#define NORM_DECODE_ATI2N 1
#define NORM_DECODE_ATI2N_ALPHA 2

float4 DecompressNormal(sampler NormalSampler, float2 tc,
                        int nDecompressionMode, sampler AlphaSampler) {
    float4 normalTexel = tex2D(NormalSampler, tc);
    float4 result;

    if (nDecompressionMode == NORM_DECODE_NONE) {
        result = float4(normalTexel.xyz * 2.0f - 1.0f, normalTexel.a);
    } else if (nDecompressionMode == NORM_DECODE_ATI2N) {
        result.xy = normalTexel.xy * 2.0f - 1.0f;
        result.z = sqrt(1.0f - dot(result.xy, result.xy));
        result.a = 1.0f;
    } else  // ATI2N plus ATI1N for alpha
    {
        result.xy = normalTexel.xy * 2.0f - 1.0f;
        result.z = sqrt(1.0f - dot(result.xy, result.xy));
        result.a = tex2D(AlphaSampler, tc)
                       .x;  // Note that this comes in on the X channel
    }

    return result;
}

float4 DecompressNormal(sampler NormalSampler, float2 tc,
                        int nDecompressionMode) {
    return DecompressNormal(NormalSampler, tc, nDecompressionMode,
                            NormalSampler);
}

HALF3 NormalizeWithCubemap(sampler normalizeSampler, HALF3 input) {
    //	return texCUBE( normalizeSampler, input ) * 2.0f - 1.0f;
    return texCUBE(normalizeSampler, input);
}

/*
HALF4 EnvReflect( sampler envmapSampler,
                                 sampler normalizeSampler,
                                 HALF3 normal,
                                 float3 eye,
                                 HALF2 fresnelScaleBias )
{
        HALF3 normEye = NormalizeWithCubemap( normalizeSampler, eye );
        HALF fresnel = Fresnel( normal, normEye, fresnelScaleBias );
        HALF3 reflect = CalcReflectionVectorUnnormalized( normal, eye );
        return texCUBE( envmapSampler, reflect );
}
*/

float CalcWaterFogAlpha(const float flWaterZ, const float flEyePosZ,
                        const float flWorldPosZ, const float flProjPosZ,
                        const float flFogOORange) {
    //	float flDepthFromWater = flWaterZ - flWorldPosZ + 2.0f; // hackity hack
    //. .this is for the DF_FUDGE_UP in view_scene.cpp
    float flDepthFromWater = flWaterZ - flWorldPosZ;

    // if flDepthFromWater < 0, then set it to 0
    // This is the equivalent of moving the vert to the water surface if it's
    // above the water surface We'll do this with the saturate at the end
    // instead.
    //	flDepthFromWater = max( 0.0f, flDepthFromWater );

    // Calculate the ratio of water fog to regular fog (ie. how much of the
    // distance from the viewer to the vert is actually underwater.
    float flDepthFromEye = flEyePosZ - flWorldPosZ;
    float f = saturate(flDepthFromWater * (1.0 / flDepthFromEye));

    // $tmp.w is now the distance that we see through water.
    return saturate(f * flProjPosZ * flFogOORange);
}

float CalcRangeFog(const float flProjPosZ, const float flFogStartOverRange,
                   const float flFogMaxDensity, const float flFogOORange) {
#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || \
      defined(SHADER_MODEL_PS_2_0))  // Minimum requirement of ps2b
    return saturate(min(flFogMaxDensity,
                        (flProjPosZ * flFogOORange) - flFogStartOverRange));
#else
    return 0.0f;  // ps20 shaders will never have range fog enabled because too
                  // many ran out of slots.
#endif
}

float CalcPixelFogFactor(int iPIXELFOGTYPE, const float4 fogParams,
                         const float flEyePosZ, const float flWorldPosZ,
                         const float flProjPosZ) {
    float retVal;
    if (iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE) {
        retVal = 0.0f;
    }
    if (iPIXELFOGTYPE == PIXEL_FOG_TYPE_RANGE)  // range fog, or no fog
                                                // depending on fog parameters
    {
        retVal =
            CalcRangeFog(flProjPosZ, fogParams.x, fogParams.z, fogParams.w);
    } else if (iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT)  // height fog
    {
        retVal = CalcWaterFogAlpha(fogParams.y, flEyePosZ, flWorldPosZ,
                                   flProjPosZ, fogParams.w);
    }

    return retVal;
}

// g_FogParams not defined by default, but this is the same layout for every
// shader that does define it
#define g_FogEndOverRange g_FogParams.x
#define g_WaterZ g_FogParams.y
#define g_FogMaxDensity g_FogParams.z
#define g_FogOORange g_FogParams.w

float3 BlendPixelFog(const float3 vShaderColor, float pixelFogFactor,
                     const float3 vFogColor, const int iPIXELFOGTYPE) {
    if (iPIXELFOGTYPE ==
        PIXEL_FOG_TYPE_RANGE)  // either range fog or no fog depending on fog
                               // parameters and whether this is ps20 or ps2b
    {
#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || \
      defined(SHADER_MODEL_PS_2_0))  // Minimum requirement of ps2b
        pixelFogFactor = saturate(pixelFogFactor);
        return lerp(
            vShaderColor.rgb, vFogColor.rgb,
            pixelFogFactor *
                pixelFogFactor);  // squaring the factor will get the middle
                                  // range mixing closer to hardware fog
#else
        return vShaderColor;
#endif
    } else if (iPIXELFOGTYPE == PIXEL_FOG_TYPE_HEIGHT) {
        return lerp(vShaderColor.rgb, vFogColor.rgb, saturate(pixelFogFactor));
    } else if (iPIXELFOGTYPE == PIXEL_FOG_TYPE_NONE) {
        return vShaderColor;
    }
}

#if ((defined(SHADER_MODEL_PS_2_B) || defined(SHADER_MODEL_PS_3_0)) && \
     (CONVERT_TO_SRGB != 0))
sampler1D GammaTableSampler : register(s15);

float3 SRGBOutput(const float3 vShaderColor) {
    // On ps2b capable hardware we always have the linear->gamma conversion
    // table texture in sampler s15.
    float3 result;
    result.r = tex1D(GammaTableSampler, vShaderColor.r).r;
    result.g = tex1D(GammaTableSampler, vShaderColor.g).r;
    result.b = tex1D(GammaTableSampler, vShaderColor.b).r;
    return result;
}

#else

float3 SRGBOutput(const float3 vShaderColor) {
    return vShaderColor;  // ps 1.1, 1.4, and 2.0 never do srgb conversion in
                          // the pixel shader
}

#endif

float SoftParticleDepth(float flDepth) {
    return flDepth * OO_DESTALPHA_DEPTH_RANGE;
}

float DepthToDestAlpha(const float flProjZ) {
#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || \
      defined(SHADER_MODEL_PS_2_0))  // Minimum requirement of ps2b
    return SoftParticleDepth(flProjZ);
#else
    return 1.0f;
#endif
}

float4 FinalOutput(const float4 vShaderColor, float pixelFogFactor,
                   const int iPIXELFOGTYPE, const int iTONEMAP_SCALE_TYPE,
                   const bool bWriteDepthToDestAlpha = false,
                   const float flProjZ = 1.0f) {
    float4 result;
    if (iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_LINEAR) {
        result.rgb = vShaderColor.rgb * LINEAR_LIGHT_SCALE;
    } else if (iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_GAMMA) {
        result.rgb = vShaderColor.rgb * GAMMA_LIGHT_SCALE;
    } else if (iTONEMAP_SCALE_TYPE == TONEMAP_SCALE_NONE) {
        result.rgb = vShaderColor.rgb;
    }

    if (bWriteDepthToDestAlpha)
        result.a = DepthToDestAlpha(flProjZ);
    else
        result.a = vShaderColor.a;

    result.rgb = BlendPixelFog(result.rgb, pixelFogFactor, g_LinearFogColor.rgb,
                               iPIXELFOGTYPE);

#if !(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || \
      defined(SHADER_MODEL_PS_2_0))       // Minimum requirement of ps2b
    result.rgb = SRGBOutput(result.rgb);  // SRGB in pixel shader conversion
#endif

    return result;
}

LPREVIEW_PS_OUT FinalOutput(const LPREVIEW_PS_OUT vShaderColor,
                            float pixelFogFactor, const int iPIXELFOGTYPE,
                            const int iTONEMAP_SCALE_TYPE) {
    LPREVIEW_PS_OUT result;
    result.color = FinalOutput(vShaderColor.color, pixelFogFactor,
                               iPIXELFOGTYPE, iTONEMAP_SCALE_TYPE);
    result.normal.rgb = SRGBOutput(vShaderColor.normal.rgb);
    result.normal.a = vShaderColor.normal.a;

    result.position.rgb = SRGBOutput(vShaderColor.position.rgb);
    result.position.a = vShaderColor.position.a;

    result.flags.rgb = SRGBOutput(vShaderColor.flags.rgb);
    result.flags.a = vShaderColor.flags.a;

    return result;
}

float RemapValClamped(float val, float A, float B, float C, float D) {
    float cVal = (val - A) / (B - A);
    cVal = saturate(cVal);

    return C + (D - C) * cVal;
}

//===================================================================================//
// This is based on Natasha Tatarchuk's Parallax Occlusion Mapping (ATI)
//===================================================================================//
// INPUT:
//		inTexCoord:
//			the texcoord for the height/displacement map before
//parallaxing
//
//		vParallax:
//			Compute initial parallax displacement direction:
//			float2 vParallaxDirection = normalize( vViewTS.xy );
//			float fLength = length( vViewTS );
//			float fParallaxLength = sqrt( fLength * fLength - vViewTS.z
//* vViewTS.z ) / vViewTS.z; 			Out.vParallax = vParallaxDirection *
//fParallaxLength * fProjectedBumpHeight;
//
//		vNormal:
//			tangent space normal
//
//		vViewW:
//			float3 vViewW = /*normalize*/(mul( matViewInverse, float4(
//0, 0, 0, 1)) - inPosition );
//
// OUTPUT:
//		the new texcoord after parallaxing
float2 CalcParallaxedTexCoord(float2 inTexCoord, float2 vParallax,
                              float3 vNormal, float3 vViewW,
                              sampler HeightMapSampler) {
    const int nMinSamples = 8;
    const int nMaxSamples = 50;

    //  Normalize the incoming view vector to avoid artifacts:
    //   vView = normalize( vView );
    vViewW = normalize(vViewW);
    //   vLight = normalize( vLight );

    // Change the number of samples per ray depending on the viewing angle
    // for the surface. Oblique angles require smaller step sizes to achieve
    // more accurate precision
    int nNumSteps = (int)lerp(nMaxSamples, nMinSamples, dot(vViewW, vNormal));

    float4 cResultColor = float4(0, 0, 0, 1);

    //===============================================//
    // Parallax occlusion mapping offset computation //
    //===============================================//
    float fCurrHeight = 0.0;
    float fStepSize = 1.0 / (float)nNumSteps;
    float fPrevHeight = 1.0;
    float fNextHeight = 0.0;

    int nStepIndex = 0;
    //   bool bCondition = true;

    float2 dx = ddx(inTexCoord);
    float2 dy = ddy(inTexCoord);

    float2 vTexOffsetPerStep = fStepSize * vParallax;

    float2 vTexCurrentOffset = inTexCoord;
    float fCurrentBound = 1.0;

    float x = 0;
    float y = 0;
    float xh = 0;
    float yh = 0;

    float2 texOffset2 = 0;

    bool bCondition = true;
    while (bCondition == true && nStepIndex < nNumSteps) {
        vTexCurrentOffset -= vTexOffsetPerStep;

        fCurrHeight = tex2Dgrad(HeightMapSampler, vTexCurrentOffset, dx, dy).r;

        fCurrentBound -= fStepSize;

        if (fCurrHeight > fCurrentBound) {
            x = fCurrentBound;
            y = fCurrentBound + fStepSize;
            xh = fCurrHeight;
            yh = fPrevHeight;

            texOffset2 = vTexCurrentOffset - vTexOffsetPerStep;

            bCondition = false;
        } else {
            nStepIndex++;
            fPrevHeight = fCurrHeight;
        }

    }  // End of while ( bCondition == true && nStepIndex > -1 )#else

    fCurrentBound -= fStepSize;

    float fParallaxAmount;
    float numerator = (x * (y - yh) - y * (x - xh));
    float denomenator = ((y - yh) - (x - xh));
    // avoid NaN generation
    if ((numerator == 0.0f) && (denomenator == 0.0f)) {
        fParallaxAmount = 0.0f;
    } else {
        fParallaxAmount = numerator / denomenator;
    }

    float2 vParallaxOffset = vParallax * (1 - fParallaxAmount);

    // Sample the height at the next possible step:
    fNextHeight = tex2Dgrad(HeightMapSampler, texOffset2, dx, dy).r;

    // Original offset:
    float2 texSampleBase = inTexCoord - vParallaxOffset;

    return texSampleBase;

#if 0
   cResultColor.rgb = ComputeDiffuseColor( texSampleBase, vLight );
        
   float fBound = 1.0 - fStepSize * nStepIndex;
   if ( fNextHeight < fCurrentBound )
//    if( 0 )
   {
      //void DoIteration( in float2 vParallaxJittered, in float3 vLight, inout float4 cResultColor )
      //cResultColor.rgb = float3(1,0,0);
      DoIteration( vParallax + vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
      DoIteration( vParallax - vPixelSize, vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
      DoIteration( vParallax + float2( -vPixelSize.x, vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );
      DoIteration( vParallax + float2( vPixelSize.x, -vPixelSize.y ), vLight, fStepSize, inTexCoord, nStepIndex, dx, dy, fBound, cResultColor );

      cResultColor.rgb /= 5;
//      cResultColor.rgb = float3( 1.0f, 0.0f, 0.0f );
   }   // End of if ( fNextHeight < fCurrentBound )

#if DOSHADOWS
   {
      //============================================//
      // Soft shadow and self-occlusion computation //
      //============================================//
      // Compute the blurry shadows (note that this computation takes into 
      // account self-occlusion for shadow computation):
      float sh0 =  tex2D( sNormalMap, texSampleBase).w;
      float shA = (tex2D( sNormalMap, texSampleBase + inXY * 0.88 ).w - sh0 - 0.88 ) *  1 * fShadowSoftening;
      float sh9 = (tex2D( sNormalMap, texSampleBase + inXY * 0.77 ).w - sh0 - 0.77 ) *  2 * fShadowSoftening;
      float sh8 = (tex2D( sNormalMap, texSampleBase + inXY * 0.66 ).w - sh0 - 0.66 ) *  4 * fShadowSoftening;
      float sh7 = (tex2D( sNormalMap, texSampleBase + inXY * 0.55 ).w - sh0 - 0.55 ) *  6 * fShadowSoftening;
      float sh6 = (tex2D( sNormalMap, texSampleBase + inXY * 0.44 ).w - sh0 - 0.44 ) *  8 * fShadowSoftening;
      float sh5 = (tex2D( sNormalMap, texSampleBase + inXY * 0.33 ).w - sh0 - 0.33 ) * 10 * fShadowSoftening;
      float sh4 = (tex2D( sNormalMap, texSampleBase + inXY * 0.22 ).w - sh0 - 0.22 ) * 12 * fShadowSoftening;
      
      // Compute the actual shadow strength:
      float fShadow = 1 - max( max( max( max( max( max( shA, sh9 ), sh8 ), sh7 ), sh6 ), sh5 ), sh4 );

      cResultColor.rgb *= fShadow * 0.6 + 0.4;
   }
#endif
   
   return cResultColor;
#endif
}

//======================================//
// HSL Color space conversion routines  //
//======================================//

#define HUE 0
#define SATURATION 1
#define LIGHTNESS 2

// Convert from RGB to HSL color space
float4 RGBtoHSL(float4 inColor) {
    float h, s;
    float flMax = max(inColor.r, max(inColor.g, inColor.b));
    float flMin = min(inColor.r, min(inColor.g, inColor.b));

    float l = (flMax + flMin) / 2.0f;

    if (flMax == flMin)  // achromatic case
    {
        s = h = 0;
    } else  // chromatic case
    {
        // Next, calculate the hue
        float delta = flMax - flMin;

        // First, calculate the saturation
        if (l < 0.5f)  // If we're in the lower hexcone
        {
            s = delta / (flMax + flMin);
        } else {
            s = delta / (2 - flMax - flMin);
        }

        if (inColor.r == flMax) {
            h = (inColor.g - inColor.b) /
                delta;  // color between yellow and magenta
        } else if (inColor.g == flMax) {
            h = 2 + (inColor.b - inColor.r) /
                        delta;  // color between cyan and yellow
        } else                  // blue must be max
        {
            h = 4 + (inColor.r - inColor.g) /
                        delta;  // color between magenta and cyan
        }

        h *= 60.0f;

        if (h < 0.0f) {
            h += 360.0f;
        }

        h /= 360.0f;
    }

    return float4(h, s, l, 1.0f);
}

float HueToRGB(float v1, float v2, float vH) {
    float fResult = v1;

    vH = fmod(vH + 1.0f, 1.0f);

    if ((6.0f * vH) < 1.0f) {
        fResult = (v1 + (v2 - v1) * 6.0f * vH);
    } else if ((2.0f * vH) < 1.0f) {
        fResult = (v2);
    } else if ((3.0f * vH) < 2.0f) {
        fResult = (v1 + (v2 - v1) * ((2.0f / 3.0f) - vH) * 6.0f);
    }

    return fResult;
}

// Convert from HSL to RGB color space
float4 HSLtoRGB(float4 hsl) {
    float r, g, b;
    float h = hsl[HUE];
    float s = hsl[SATURATION];
    float l = hsl[LIGHTNESS];

    if (s == 0) {
        r = g = b = l;
    } else {
        float v1, v2;

        if (l < 0.5f)
            v2 = l * (1.0f + s);
        else
            v2 = (l + s) - (s * l);

        v1 = 2 * l - v2;

        r = HueToRGB(v1, v2, h + (1.0f / 3.0f));
        g = HueToRGB(v1, v2, h);
        b = HueToRGB(v1, v2, h - (1.0f / 3.0f));
    }

    return float4(r, g, b, 1.0f);
}

// texture combining modes for combining base and detail/basetexture2
#define TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2 0  // original mode
#define TCOMBINE_RGB_ADDITIVE 1                // base.rgb+detail.rgb*fblend
#define TCOMBINE_DETAIL_OVER_BASE 2
#define TCOMBINE_FADE 3              // straight fade between base and detail.
#define TCOMBINE_BASE_OVER_DETAIL 4  // use base alpha for blend over detail
#define TCOMBINE_RGB_ADDITIVE_SELFILLUM 5  // add detail color post lighting
#define TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE 6
#define TCOMBINE_MOD2X_SELECT_TWO_PATTERNS \
    7  // use alpha channel of base to select between mod2x channels in r+a of
       // detail
#define TCOMBINE_MULTIPLY 8
#define TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA \
    9                            // use alpha channel of detail to mask base
#define TCOMBINE_SSBUMP_BUMP 10  // use detail to modulate lighting as an ssbump
#define TCOMBINE_SSBUMP_NOBUMP \
    11  // detail is an ssbump but use it as an albedo. shader does the magic
        // here - no user needs to specify mode 11

float4 TextureCombine(float4 baseColor, float4 detailColor, int combine_mode,
                      float fBlendFactor) {
    if (combine_mode == TCOMBINE_MOD2X_SELECT_TWO_PATTERNS) {
        float3 dc = lerp(detailColor.r, detailColor.a, baseColor.a);
        baseColor.rgb *= lerp(float3(1, 1, 1), 2.0 * dc, fBlendFactor);
    }
    if (combine_mode == TCOMBINE_RGB_EQUALS_BASE_x_DETAILx2)
        baseColor.rgb *=
            lerp(float3(1, 1, 1), 2.0 * detailColor.rgb, fBlendFactor);
    if (combine_mode == TCOMBINE_RGB_ADDITIVE)
        baseColor.rgb += fBlendFactor * detailColor.rgb;
    if (combine_mode == TCOMBINE_DETAIL_OVER_BASE) {
        float fblend = fBlendFactor * detailColor.a;
        baseColor.rgb = lerp(baseColor.rgb, detailColor.rgb, fblend);
    }
    if (combine_mode == TCOMBINE_FADE) {
        baseColor = lerp(baseColor, detailColor, fBlendFactor);
    }
    if (combine_mode == TCOMBINE_BASE_OVER_DETAIL) {
        float fblend = fBlendFactor * (1 - baseColor.a);
        baseColor.rgb = lerp(baseColor.rgb, detailColor.rgb, fblend);
        baseColor.a = detailColor.a;
    }
    if (combine_mode == TCOMBINE_MULTIPLY) {
        baseColor = lerp(baseColor, baseColor * detailColor, fBlendFactor);
    }

    if (combine_mode == TCOMBINE_MASK_BASE_BY_DETAIL_ALPHA) {
        baseColor.a =
            lerp(baseColor.a, baseColor.a * detailColor.a, fBlendFactor);
    }
    if (combine_mode == TCOMBINE_SSBUMP_NOBUMP) {
        baseColor.rgb = baseColor.rgb * dot(detailColor.rgb, 2.0 / 3.0);
    }
    return baseColor;
}

float3 lerp5(float3 f1, float3 f2, float i1, float i2, float x) {
    return f1 + (f2 - f1) * (x - i1) / (i2 - i1);
}

float3 TextureCombinePostLighting(float3 lit_baseColor, float4 detailColor,
                                  int combine_mode, float fBlendFactor) {
    if (combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM)
        lit_baseColor += fBlendFactor * detailColor.rgb;
    if (combine_mode == TCOMBINE_RGB_ADDITIVE_SELFILLUM_THRESHOLD_FADE) {
        // fade in an unusual way - instead of fading out color, remap an
        // increasing band of it from 0..1
        // if (fBlendFactor > 0.5)
        //	lit_baseColor += min(1, (1.0/fBlendFactor)*max(0,
        //detailColor.rgb-(1-fBlendFactor) ) ); else 	lit_baseColor +=
        //2*fBlendFactor*2*max(0, detailColor.rgb-.5);

        float f = fBlendFactor - 0.5;
        float fMult = (f >= 0) ? 1.0 / fBlendFactor : 4 * fBlendFactor;
        float fAdd = (f >= 0) ? 1.0 - fMult : -0.5 * fMult;
        lit_baseColor += saturate(fMult * detailColor.rgb + fAdd);
    }
    return lit_baseColor;
}

// NOTE: On X360. fProjZ is expected to be pre-reversed for cheaper math here in
// the pixel shader
float DepthFeathering(sampler DepthSampler, const float2 vScreenPos,
                      float fProjZ, float fProjW, float4 vDepthBlendConstants) {
#if (!(defined(SHADER_MODEL_PS_1_1) || defined(SHADER_MODEL_PS_1_4) || \
       defined(SHADER_MODEL_PS_2_0)))  // minimum requirement of ps2b
    {
        float flFeatheredAlpha;
        float2 flDepths;
#define flSceneDepth flDepths.x
#define flSpriteDepth flDepths.y

#if (defined(_X360))
        {
            // Get depth from the depth texture. Need to sample with the offset
            // of (0.5, 0.5) to fix rounding errors
            asm {
				tfetch2D flDepths.x___, vScreenPos, DepthSampler, OffsetX=0.5, OffsetY=0.5, MinFilter=point, MagFilter=point, MipFilter=point
            }
            ;

#if (!defined(REVERSE_DEPTH_ON_X360))
            flSceneDepth = 1.0f - flSceneDepth;
#endif

            // get the sprite depth into the same range as the texture depth
            flSpriteDepth = fProjZ / fProjW;

            // unproject to get at the pre-projection z. This value is much more
            // linear than depth
            flDepths = vDepthBlendConstants.z / flDepths;
            flDepths = vDepthBlendConstants.y - flDepths;

            flFeatheredAlpha = flSceneDepth - flSpriteDepth;
            flFeatheredAlpha *= vDepthBlendConstants.x;
            flFeatheredAlpha = saturate(flFeatheredAlpha);
        }
#else
        {
            flSceneDepth = tex2D(DepthSampler, vScreenPos)
                               .a;  // PC uses dest alpha of the frame buffer
            flSpriteDepth = SoftParticleDepth(fProjZ);

            flFeatheredAlpha =
                abs(flSceneDepth - flSpriteDepth) * vDepthBlendConstants.x;
            flFeatheredAlpha = max(
                smoothstep(0.75f, 1.0f, flSceneDepth),
                flFeatheredAlpha);  // as the sprite approaches the edge of our
                                    // compressed depth space, the math stops
                                    // working. So as the sprite approaches the
                                    // far depth, smoothly remove feathering.
            flFeatheredAlpha = saturate(flFeatheredAlpha);
        }
#endif

#undef flSceneDepth
#undef flSpriteDepth

        return flFeatheredAlpha;
    }
#else
    { return 1.0f; }
#endif
}

#endif  //#ifndef COMMON_PS_FXC_H_