//
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// TextureFunctionHLSL: Class for writing implementations of ESSL texture functions into HLSL
// output. Some of the implementations are straightforward and just call the HLSL equivalent of the
// ESSL texture function, others do more work to emulate ESSL texture sampling or size query
// behavior.
//

#include "compiler/translator/TextureFunctionHLSL.h"

#include "compiler/translator/ImmutableStringBuilder.h"
#include "compiler/translator/UtilsHLSL.h"

namespace sh
{

namespace
{

void OutputIntTexCoordWrap(TInfoSinkBase &out,
                           const char *wrapMode,
                           const char *size,
                           const ImmutableString &texCoord,
                           const char *texCoordOffset,
                           const char *texCoordOutName)
{
    // GLES 3.0.4 table 3.22 specifies how the wrap modes work. We don't use the formulas verbatim
    // but rather use equivalent formulas that map better to HLSL.
    out << "int " << texCoordOutName << ";\n";
    out << "float " << texCoordOutName << "Offset = " << texCoord << " + float(" << texCoordOffset
        << ") / " << size << ";\n";
    out << "bool " << texCoordOutName << "UseBorderColor = false;\n";

    // CLAMP_TO_EDGE
    out << "if (" << wrapMode << " == 0)\n";
    out << "{\n";
    out << "    " << texCoordOutName << " = clamp(int(floor(" << size << " * " << texCoordOutName
        << "Offset)), 0, int(" << size << ") - 1);\n";
    out << "}\n";

    // CLAMP_TO_BORDER
    out << "else if (" << wrapMode << " == 3)\n";
    out << "{\n";
    out << "    int texCoordInt = int(floor(" << size << " * " << texCoordOutName << "Offset));\n";
    out << "    " << texCoordOutName << " = clamp(texCoordInt, 0, int(" << size << ") - 1);\n";
    out << "    " << texCoordOutName << "UseBorderColor = (texCoordInt != " << texCoordOutName
        << ");\n";
    out << "}\n";

    // MIRRORED_REPEAT
    out << "else if (" << wrapMode << " == 2)\n";
    out << "{\n";
    out << "    float coordWrapped = 1.0 - abs(frac(abs(" << texCoordOutName
        << "Offset) * 0.5) * 2.0 - 1.0);\n";
    out << "    " << texCoordOutName << " = int(floor(" << size << " * coordWrapped));\n";
    out << "}\n";

    // REPEAT
    out << "else\n";
    out << "{\n";
    out << "    " << texCoordOutName << " = int(floor(" << size << " * frac(" << texCoordOutName
        << "Offset)));\n";
    out << "}\n";
}

void OutputIntTexCoordWraps(TInfoSinkBase &out,
                            const TextureFunctionHLSL::TextureFunction &textureFunction,
                            ImmutableString *texCoordX,
                            ImmutableString *texCoordY,
                            ImmutableString *texCoordZ)
{
    // Convert from normalized floating-point to integer
    out << "int wrapS = samplerMetadata[samplerIndex].wrapModes & 0x3;\n";
    if (textureFunction.offset)
    {
        OutputIntTexCoordWrap(out, "wrapS", "width", *texCoordX, "offset.x", "tix");
    }
    else
    {
        OutputIntTexCoordWrap(out, "wrapS", "width", *texCoordX, "0", "tix");
    }
    *texCoordX = ImmutableString("tix");
    out << "int wrapT = (samplerMetadata[samplerIndex].wrapModes >> 2) & 0x3;\n";
    if (textureFunction.offset)
    {
        OutputIntTexCoordWrap(out, "wrapT", "height", *texCoordY, "offset.y", "tiy");
    }
    else
    {
        OutputIntTexCoordWrap(out, "wrapT", "height", *texCoordY, "0", "tiy");
    }
    *texCoordY = ImmutableString("tiy");

    bool tizAvailable = false;

    if (IsSamplerArray(textureFunction.sampler))
    {
        *texCoordZ = ImmutableString("int(max(0, min(layers - 1, floor(0.5 + t.z))))");
    }
    else if (!IsSamplerCube(textureFunction.sampler) && !IsSampler2D(textureFunction.sampler))
    {
        out << "int wrapR = (samplerMetadata[samplerIndex].wrapModes >> 4) & 0x3;\n";
        if (textureFunction.offset)
        {
            OutputIntTexCoordWrap(out, "wrapR", "depth", *texCoordZ, "offset.z", "tiz");
        }
        else
        {
            OutputIntTexCoordWrap(out, "wrapR", "depth", *texCoordZ, "0", "tiz");
        }
        *texCoordZ   = ImmutableString("tiz");
        tizAvailable = true;
    }

    out << "bool useBorderColor = tixUseBorderColor || tiyUseBorderColor"
        << (tizAvailable ? " || tizUseBorderColor" : "") << ";\n";
}

void OutputHLSL4SampleFunctionPrefix(TInfoSinkBase &out,
                                     const TextureFunctionHLSL::TextureFunction &textureFunction,
                                     const ImmutableString &textureReference,
                                     const ImmutableString &samplerReference)
{
    out << textureReference;
    if (IsIntegerSampler(textureFunction.sampler) ||
        textureFunction.method == TextureFunctionHLSL::TextureFunction::FETCH)
    {
        out << ".Load(";
        return;
    }

    if (IsShadowSampler(textureFunction.sampler))
    {
        switch (textureFunction.method)
        {
            case TextureFunctionHLSL::TextureFunction::IMPLICIT:
            case TextureFunctionHLSL::TextureFunction::BIAS:
            case TextureFunctionHLSL::TextureFunction::LOD:
                out << ".SampleCmp(";
                break;
            case TextureFunctionHLSL::TextureFunction::LOD0:
            case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
            case TextureFunctionHLSL::TextureFunction::GRAD:
                out << ".SampleCmpLevelZero(";
                break;
            default:
                UNREACHABLE();
        }
    }
    else
    {
        switch (textureFunction.method)
        {
            case TextureFunctionHLSL::TextureFunction::IMPLICIT:
                out << ".Sample(";
                break;
            case TextureFunctionHLSL::TextureFunction::BIAS:
                out << ".SampleBias(";
                break;
            case TextureFunctionHLSL::TextureFunction::LOD:
            case TextureFunctionHLSL::TextureFunction::LOD0:
            case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
                out << ".SampleLevel(";
                break;
            case TextureFunctionHLSL::TextureFunction::GRAD:
                out << ".SampleGrad(";
                break;
            default:
                UNREACHABLE();
        }
    }
    out << samplerReference << ", ";
}

const char *GetSamplerCoordinateTypeString(
    const TextureFunctionHLSL::TextureFunction &textureFunction,
    int hlslCoords)
{
    // Gather[Red|Green|Blue|Alpha] accepts float texture coordinates on textures in integer or
    // unsigned integer formats.
    // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-to-gather
    if ((IsIntegerSampler(textureFunction.sampler) &&
         textureFunction.method != TextureFunctionHLSL::TextureFunction::GATHER) ||
        textureFunction.method == TextureFunctionHLSL::TextureFunction::FETCH)
    {
        switch (hlslCoords)
        {
            case 1:
                return "int";
            case 2:
                if (IsSampler2DMS(textureFunction.sampler))
                {
                    return "int2";
                }
                else
                {
                    return "int3";
                }
            case 3:
                if (IsSampler2DMSArray(textureFunction.sampler))
                {
                    return "int3";
                }
                else
                {
                    return "int4";
                }
            default:
                UNREACHABLE();
        }
    }
    else
    {
        switch (hlslCoords)
        {
            case 1:
                return "float";
            case 2:
                return "float2";
            case 3:
                return "float3";
            case 4:
                return "float4";
            default:
                UNREACHABLE();
        }
    }
    return "";
}

int GetHLSLCoordCount(const TextureFunctionHLSL::TextureFunction &textureFunction,
                      ShShaderOutput outputType)
{
    if (outputType == SH_HLSL_3_0_OUTPUT)
    {
        int hlslCoords = 2;
        switch (textureFunction.sampler)
        {
            case EbtSamplerBuffer:
                hlslCoords = 1;
                break;
            case EbtSampler2D:
            case EbtSamplerExternalOES:
            case EbtSampler2DMS:
            case EbtSamplerVideoWEBGL:
                hlslCoords = 2;
                break;
            case EbtSamplerCube:
                hlslCoords = 3;
                break;
            default:
                UNREACHABLE();
        }

        switch (textureFunction.method)
        {
            case TextureFunctionHLSL::TextureFunction::IMPLICIT:
            case TextureFunctionHLSL::TextureFunction::GRAD:
                return hlslCoords;
            case TextureFunctionHLSL::TextureFunction::BIAS:
            case TextureFunctionHLSL::TextureFunction::LOD:
            case TextureFunctionHLSL::TextureFunction::LOD0:
            case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
                return 4;
            default:
                UNREACHABLE();
        }
    }
    else
    {
        if (IsSamplerBuffer(textureFunction.sampler))
        {
            return 1;
        }
        else if (IsSampler3D(textureFunction.sampler) || IsSamplerArray(textureFunction.sampler) ||
                 IsSamplerCube(textureFunction.sampler))
        {
            return 3;
        }
        ASSERT(IsSampler2D(textureFunction.sampler));
        return 2;
    }
    return 0;
}

void OutputTextureFunctionArgumentList(TInfoSinkBase &out,
                                       const TextureFunctionHLSL::TextureFunction &textureFunction,
                                       const ShShaderOutput outputType)
{
    if (outputType == SH_HLSL_3_0_OUTPUT)
    {
        switch (textureFunction.sampler)
        {
            case EbtSampler2D:
            case EbtSamplerVideoWEBGL:
            case EbtSamplerExternalOES:
                out << "sampler2D s";
                break;
            case EbtSamplerCube:
                out << "samplerCUBE s";
                break;
            default:
                UNREACHABLE();
        }
    }
    else
    {
        if (outputType == SH_HLSL_4_0_FL9_3_OUTPUT)
        {
            out << TextureString(textureFunction.sampler) << " x, "
                << SamplerString(textureFunction.sampler) << " s";
        }
        else
        {
            ASSERT(outputType == SH_HLSL_4_1_OUTPUT);
            // A bug in the D3D compiler causes some nested sampling operations to fail.
            // See http://anglebug.com/1923
            // TODO(jmadill): Reinstate the const keyword when possible.
            out << /*"const"*/ "uint samplerIndex";
        }
    }

    if (textureFunction.method ==
        TextureFunctionHLSL::TextureFunction::FETCH)  // Integer coordinates
    {
        switch (textureFunction.coords)
        {
            case 1:
                out << ", int t";
                break;
            case 2:
                out << ", int2 t";
                break;
            case 3:
                out << ", int3 t";
                break;
            default:
                UNREACHABLE();
        }
    }
    else  // Floating-point coordinates (except textureSize)
    {
        switch (textureFunction.coords)
        {
            case 0:
                break;  // textureSize(gSampler2DMS sampler)
            case 1:
                out << ", int lod";
                break;  // textureSize()
            case 2:
                out << ", float2 t";
                break;
            case 3:
                out << ", float3 t";
                break;
            case 4:
                out << ", float4 t";
                break;
            default:
                UNREACHABLE();
        }
    }

    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
    {
        switch (textureFunction.sampler)
        {
            case EbtSampler2D:
            case EbtISampler2D:
            case EbtUSampler2D:
            case EbtSampler2DArray:
            case EbtISampler2DArray:
            case EbtUSampler2DArray:
            case EbtSampler2DShadow:
            case EbtSampler2DArrayShadow:
            case EbtSamplerExternalOES:
            case EbtSamplerVideoWEBGL:
                out << ", float2 ddx, float2 ddy";
                break;
            case EbtSampler3D:
            case EbtISampler3D:
            case EbtUSampler3D:
            case EbtSamplerCube:
            case EbtISamplerCube:
            case EbtUSamplerCube:
            case EbtSamplerCubeShadow:
                out << ", float3 ddx, float3 ddy";
                break;
            default:
                UNREACHABLE();
        }
    }

    switch (textureFunction.method)
    {
        case TextureFunctionHLSL::TextureFunction::IMPLICIT:
            break;
        case TextureFunctionHLSL::TextureFunction::BIAS:
            break;  // Comes after the offset parameter
        case TextureFunctionHLSL::TextureFunction::LOD:
            out << ", float lod";
            break;
        case TextureFunctionHLSL::TextureFunction::LOD0:
            break;
        case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
            break;  // Comes after the offset parameter
        case TextureFunctionHLSL::TextureFunction::SIZE:
            break;
        case TextureFunctionHLSL::TextureFunction::FETCH:
            if (IsSampler2DMS(textureFunction.sampler) ||
                IsSampler2DMSArray(textureFunction.sampler))
                out << ", int index";
            else if (!IsSamplerBuffer(textureFunction.sampler))
                out << ", int mip";
            break;
        case TextureFunctionHLSL::TextureFunction::GRAD:
            break;
        case TextureFunctionHLSL::TextureFunction::GATHER:
            break;
        default:
            UNREACHABLE();
    }

    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GATHER &&
        IsShadowSampler(textureFunction.sampler))
    {
        out << ", float refZ";
    }

    if (textureFunction.offset)
    {
        switch (textureFunction.sampler)
        {
            case EbtSampler3D:
            case EbtISampler3D:
            case EbtUSampler3D:
                out << ", int3 offset";
                break;
            case EbtSampler2D:
            case EbtSampler2DArray:
            case EbtISampler2D:
            case EbtISampler2DArray:
            case EbtUSampler2D:
            case EbtUSampler2DArray:
            case EbtSampler2DShadow:
            case EbtSampler2DArrayShadow:
            case EbtSamplerExternalOES:
            case EbtSamplerVideoWEBGL:
                out << ", int2 offset";
                break;
            default:
                // Offset is not supported for multisampled textures.
                UNREACHABLE();
        }
    }

    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS ||
        textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0BIAS)
    {
        out << ", float bias";
    }
    else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GATHER &&
             !IsShadowSampler(textureFunction.sampler))
    {
        out << ", int comp = 0";
    }
}

void GetTextureReference(TInfoSinkBase &out,
                         const TextureFunctionHLSL::TextureFunction &textureFunction,
                         const ShShaderOutput outputType,
                         ImmutableString *textureReference,
                         ImmutableString *samplerReference)
{
    if (outputType == SH_HLSL_4_1_OUTPUT)
    {
        static const ImmutableString kTexturesStr("textures");
        static const ImmutableString kSamplersStr("samplers");
        static const ImmutableString kSamplerIndexStr("[samplerIndex]");
        static const ImmutableString kTextureIndexStr("[textureIndex]");
        static const ImmutableString kSamplerArrayIndexStr("[samplerArrayIndex]");
        ImmutableString suffix(TextureGroupSuffix(textureFunction.sampler));

        if (TextureGroup(textureFunction.sampler) == HLSL_TEXTURE_2D)
        {
            ImmutableStringBuilder textureRefBuilder(kTexturesStr.length() + suffix.length() +
                                                     kSamplerIndexStr.length());
            textureRefBuilder << kTexturesStr << suffix << kSamplerIndexStr;
            *textureReference = textureRefBuilder;
            ImmutableStringBuilder samplerRefBuilder(kSamplersStr.length() + suffix.length() +
                                                     kSamplerIndexStr.length());
            samplerRefBuilder << kSamplersStr << suffix << kSamplerIndexStr;
            *samplerReference = samplerRefBuilder;
        }
        else
        {
            out << "    const uint textureIndex = samplerIndex - textureIndexOffset"
                << suffix.data() << ";\n";
            ImmutableStringBuilder textureRefBuilder(kTexturesStr.length() + suffix.length() +
                                                     kTextureIndexStr.length());
            textureRefBuilder << kTexturesStr << suffix << kTextureIndexStr;
            *textureReference = textureRefBuilder;

            out << "    const uint samplerArrayIndex = samplerIndex - samplerIndexOffset"
                << suffix.data() << ";\n";
            ImmutableStringBuilder samplerRefBuilder(kSamplersStr.length() + suffix.length() +
                                                     kSamplerArrayIndexStr.length());
            samplerRefBuilder << kSamplersStr << suffix << kSamplerArrayIndexStr;
            *samplerReference = samplerRefBuilder;
        }
    }
    else
    {
        *textureReference = ImmutableString("x");
        *samplerReference = ImmutableString("s");
    }
}

void OutputTextureSizeFunctionBody(TInfoSinkBase &out,
                                   const TextureFunctionHLSL::TextureFunction &textureFunction,
                                   const ImmutableString &textureReference,
                                   bool getDimensionsIgnoresBaseLevel)
{
    if (IsSampler2DMS(textureFunction.sampler))
    {
        out << "    uint width; uint height; uint samples;\n"
            << "    " << textureReference << ".GetDimensions(width, height, samples);\n";
    }
    else if (IsSampler2DMSArray(textureFunction.sampler))
    {
        out << "    uint width; uint height; uint depth; uint samples;\n"
            << "    " << textureReference << ".GetDimensions(width, height, depth, samples);\n";
    }
    else if (IsSamplerBuffer(textureFunction.sampler))
    {
        out << "    uint width;\n"
            << "    " << textureReference << ".GetDimensions(width);\n";
    }
    else
    {
        if (getDimensionsIgnoresBaseLevel)
        {
            out << "    int baseLevel = samplerMetadata[samplerIndex].baseLevel;\n";
        }
        else
        {
            out << "    int baseLevel = 0;\n";
        }

        if (IsSampler3D(textureFunction.sampler) || IsSamplerArray(textureFunction.sampler) ||
            (IsIntegerSampler(textureFunction.sampler) && IsSamplerCube(textureFunction.sampler)))
        {
            // "depth" stores either the number of layers in an array texture or 3D depth
            out << "    uint width; uint height; uint depth; uint numberOfLevels;\n"
                << "    " << textureReference
                << ".GetDimensions(baseLevel, width, height, depth, numberOfLevels);\n"
                << "    width = max(width >> lod, 1);\n"
                << "    height = max(height >> lod, 1);\n";

            if (!IsSamplerArray(textureFunction.sampler))
            {
                out << "    depth = max(depth >> lod, 1);\n";
            }
        }
        else if (IsSampler2D(textureFunction.sampler) || IsSamplerCube(textureFunction.sampler))
        {
            out << "    uint width; uint height; uint numberOfLevels;\n"
                << "    " << textureReference
                << ".GetDimensions(baseLevel, width, height, numberOfLevels);\n"
                << "    width = max(width >> lod, 1);\n"
                << "    height = max(height >> lod, 1);\n";
        }
        else
            UNREACHABLE();
    }

    const char *returnType = textureFunction.getReturnType();
    if (strcmp(returnType, "int3") == 0)
    {
        out << "    return int3(width, height, depth);\n";
    }
    else if (strcmp(returnType, "int2") == 0)
    {
        out << "    return int2(width, height);\n";
    }
    else
    {
        out << "    return int(width);\n";
    }
}

void ProjectTextureCoordinates(const TextureFunctionHLSL::TextureFunction &textureFunction,
                               ImmutableString *texCoordX,
                               ImmutableString *texCoordY,
                               ImmutableString *texCoordZ)
{
    if (textureFunction.proj)
    {
        ImmutableString proj("");
        switch (textureFunction.coords)
        {
            case 3:
                proj = ImmutableString(" / t.z");
                break;
            case 4:
                proj = ImmutableString(" / t.w");
                break;
            default:
                UNREACHABLE();
        }
        ImmutableStringBuilder texCoordXBuilder(texCoordX->length() + proj.length() + 2u);
        texCoordXBuilder << '(' << *texCoordX << proj << ')';
        *texCoordX = texCoordXBuilder;
        ImmutableStringBuilder texCoordYBuilder(texCoordY->length() + proj.length() + 2u);
        texCoordYBuilder << '(' << *texCoordY << proj << ')';
        *texCoordY = texCoordYBuilder;
        ImmutableStringBuilder texCoordZBuilder(texCoordZ->length() + proj.length() + 2u);
        texCoordZBuilder << '(' << *texCoordZ << proj << ')';
        *texCoordZ = texCoordZBuilder;
    }
}

void OutputIntegerTextureSampleFunctionComputations(
    TInfoSinkBase &out,
    const TextureFunctionHLSL::TextureFunction &textureFunction,
    const ShShaderOutput outputType,
    const ImmutableString &textureReference,
    ImmutableString *texCoordX,
    ImmutableString *texCoordY,
    ImmutableString *texCoordZ,
    bool getDimensionsIgnoresBaseLevel)
{
    if (!IsIntegerSampler(textureFunction.sampler))
    {
        return;
    }

    if (getDimensionsIgnoresBaseLevel)
    {
        out << "    int baseLevel = samplerMetadata[samplerIndex].baseLevel;\n";
    }
    else
    {
        out << "    int baseLevel = 0;\n";
    }

    if (IsSamplerCube(textureFunction.sampler))
    {
        out << "    float width; float height; float layers; float levels;\n";

        out << "    uint mip = 0;\n";

        out << "    " << textureReference
            << ".GetDimensions(baseLevel + mip, width, height, layers, levels);\n";

        out << "    bool xMajor = abs(t.x) >= abs(t.y) && abs(t.x) >= abs(t.z);\n";
        out << "    bool yMajor = abs(t.y) >= abs(t.z) && abs(t.y) > abs(t.x);\n";
        out << "    bool zMajor = abs(t.z) > abs(t.x) && abs(t.z) > abs(t.y);\n";
        out << "    bool negative = (xMajor && t.x < 0.0f) || (yMajor && t.y < 0.0f) || "
               "(zMajor && t.z < 0.0f);\n";

        // FACE_POSITIVE_X = 000b
        // FACE_NEGATIVE_X = 001b
        // FACE_POSITIVE_Y = 010b
        // FACE_NEGATIVE_Y = 011b
        // FACE_POSITIVE_Z = 100b
        // FACE_NEGATIVE_Z = 101b
        out << "    int face = (int)negative + (int)yMajor * 2 + (int)zMajor * 4;\n";

        out << "    float u = xMajor ? -t.z : (yMajor && t.y < 0.0f ? -t.x : t.x);\n";
        out << "    float v = yMajor ? t.z : (negative ? t.y : -t.y);\n";
        out << "    float m = xMajor ? t.x : (yMajor ? t.y : t.z);\n";

        out << "    float3 r = any(t) ? t : float3(1, 0, 0);\n";
        out << "    t.x = (u * 0.5f / m) + 0.5f;\n";
        out << "    t.y = (v * 0.5f / m) + 0.5f;\n";

        // Mip level computation.
        if (textureFunction.method == TextureFunctionHLSL::TextureFunction::IMPLICIT ||
            textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD ||
            textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
        {
            if (textureFunction.method == TextureFunctionHLSL::TextureFunction::IMPLICIT)
            {
                // We would like to calculate tha maximum of how many texels we move in the major
                // face's texture as we move across the screen in any direction. Namely, we want the
                // length of the directional derivative of the function p (defined below), maximized
                // over screen space directions. (For short: we want the norm of Dp.) For
                // simplicity, assume that z-axis is the major axis. By symmetry, we can assume that
                // the positive z direction is major. (The calculated value will be the same even if
                // this is false.) Let r denote the function from screen position to cube texture
                // coordinates. Then p can be written as p = s . P . r, where P(r) = (r.x, r.y)/r.z
                // is the projection onto the major cube face, and s = diag(width, height)/2. (s
                // linearly maps from the cube face into texture space, so that p(r) is in units of
                // texels.) The derivative is
                // Dp(r) = s |1 0 -r.x/r.z|
                //           |0 1 -r.y/r.z| |ddx(r) ddy(r)| / r.z
                //       = |dot(a, ddx(r)) dot(a, ddy(r))|
                //         |dot(b, ddx(r)) dot(b, ddy(r))| / (2 r.z)
                // where a = w * vec3(1, 0, -r.x/r.z)
                //       b = h * vec3(0, 1, -r.y/r.z)
                // We would like to know max(L(x)) over unit vectors x, where L(x) = |Dp(r) x|^2.
                // Since ddx(r) and ddy(r) are unknown, the best we can do is to sample L in some
                // directions and take the maximum across the samples.
                //
                // Some implementations use max(L(n1), L(n2)) where n1 = vec2(1,0) and n2 =
                // vec2(0,1).
                //
                // Some implementations use max(L(n1), L(n2), L(n3), L(n4)),
                // where n3 = (n1 + n2) / |n1 + n2| = (n1 + n2)/sqrt(2)
                //       n4 = (n1 - n2) / |n1 - n2| = (n1 - n2)/sqrt(2).
                // In other words, two samples along the diagonal screen space directions have been
                // added, giving a strictly better estimate of the true maximum.
                //
                // It turns out we can get twice the sample count very cheaply.
                // We can use the linearity of Dp(r) to get these extra samples of L cheaply in
                // terms of the already taken samples, L(n1) and L(n2):
                // Denoting
                // dpx = Dp(r)n1
                // dpy = Dp(r)n2
                // dpxx = dot(dpx, dpx)
                // dpyy = dot(dpy, dpy)
                // dpxy = dot(dpx, dpy)
                // we obtain
                // L(n3) = |Dp(r)n1 + Dp(r)n2|^2/2 = (dpxx + dpyy)/2 + dpxy
                // L(n4) = |Dp(r)n1 - Dp(r)n2|^2/2 = (dpxx + dpyy)/2 - dpxy
                // max(L(n1), L(n2), L(n3), L(n4))
                // = max(max(L(n1), L(n2)), max(L(n3), L(n4)))
                // = max(max(dpxx, dpyy), (dpxx + dpyy)/2 + abs(dpxy))
                // So the extra cost is: one dot, one abs, one add, one multiply-add and one max.
                // (All scalar.)
                //
                // In section 3.8.10.1, the OpenGL ES 3 specification defines the "scale factor",
                // rho. In our terminology, this definition works out to taking sqrt(max(L(n1),
                // L(n2))). Some implementations will use this estimate, here we use the strictly
                // better sqrt(max(L(n1), L(n2), L(n3), L(n4))), since it's not much more expensive
                // to calculate.

                // Swap coordinates such that we can assume that the positive z-axis is major, in
                // what follows.
                out << "    float3 ddxr = xMajor ? ddx(r).yzx : yMajor ? ddx(r).zxy : ddx(r).xyz;\n"
                       "    float3 ddyr = xMajor ? ddy(r).yzx : yMajor ? ddy(r).zxy : ddy(r).xyz;\n"
                       "    r = xMajor ? r.yzx : yMajor ? r.zxy : r.xyz;\n";

                out << "    float2 s = 0.5*float2(width, height);\n"
                       "    float2 dpx = s * (ddxr.xy - ddxr.z*r.xy/r.z)/r.z;\n"
                       "    float2 dpy = s * (ddyr.xy - ddyr.z*r.xy/r.z)/r.z;\n"
                       "    float dpxx = dot(dpx, dpx);\n;"
                       "    float dpyy = dot(dpy, dpy);\n;"
                       "    float dpxy = dot(dpx, dpy);\n"
                       "    float ma = max(dpxx, dpyy);\n"
                       "    float mb = 0.5 * (dpxx + dpyy) + abs(dpxy);\n"
                       "    float mab = max(ma, mb);\n"
                       "    float lod = 0.5f * log2(mab);\n";
            }
            else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
            {
                // ESSL 3.00.6 spec section 8.8: "For the cube version, the partial
                // derivatives of P are assumed to be in the coordinate system used before
                // texture coordinates are projected onto the appropriate cube face."
                // ddx[0] and ddy[0] are the derivatives of t.x passed into the function
                // ddx[1] and ddy[1] are the derivatives of t.y passed into the function
                // ddx[2] and ddy[2] are the derivatives of t.z passed into the function
                // Determine the derivatives of u, v and m
                out << "    float dudx = xMajor ? ddx[2] : (yMajor && t.y < 0.0f ? -ddx[0] "
                       ": ddx[0]);\n"
                       "    float dudy = xMajor ? ddy[2] : (yMajor && t.y < 0.0f ? -ddy[0] "
                       ": ddy[0]);\n"
                       "    float dvdx = yMajor ? ddx[2] : (negative ? ddx[1] : -ddx[1]);\n"
                       "    float dvdy = yMajor ? ddy[2] : (negative ? ddy[1] : -ddy[1]);\n"
                       "    float dmdx = xMajor ? ddx[0] : (yMajor ? ddx[1] : ddx[2]);\n"
                       "    float dmdy = xMajor ? ddy[0] : (yMajor ? ddy[1] : ddy[2]);\n";
                // Now determine the derivatives of the face coordinates, using the
                // derivatives calculated above.
                // d / dx (u(x) * 0.5 / m(x) + 0.5)
                // = 0.5 * (m(x) * u'(x) - u(x) * m'(x)) / m(x)^2
                out << "    float dfacexdx = 0.5f * (m * dudx - u * dmdx) / (m * m);\n"
                       "    float dfaceydx = 0.5f * (m * dvdx - v * dmdx) / (m * m);\n"
                       "    float dfacexdy = 0.5f * (m * dudy - u * dmdy) / (m * m);\n"
                       "    float dfaceydy = 0.5f * (m * dvdy - v * dmdy) / (m * m);\n"
                       "    float2 sizeVec = float2(width, height);\n"
                       "    float2 faceddx = float2(dfacexdx, dfaceydx) * sizeVec;\n"
                       "    float2 faceddy = float2(dfacexdy, dfaceydy) * sizeVec;\n";
                // Optimization: instead of: log2(max(length(faceddx), length(faceddy)))
                // we compute: log2(max(length(faceddx)^2, length(faceddy)^2)) / 2
                out << "    float lengthfaceddx2 = dot(faceddx, faceddx);\n"
                       "    float lengthfaceddy2 = dot(faceddy, faceddy);\n"
                       "    float lod = log2(max(lengthfaceddx2, lengthfaceddy2)) * 0.5f;\n";
            }
            out << "    mip = uint(min(max(round(lod), 0), levels - 1));\n"
                << "    " << textureReference
                << ".GetDimensions(baseLevel + mip, width, height, layers, levels);\n";
        }

        // Convert from normalized floating-point to integer
        static const ImmutableString kXPrefix("int(floor(width * frac(");
        static const ImmutableString kYPrefix("int(floor(height * frac(");
        static const ImmutableString kSuffix(")))");
        ImmutableStringBuilder texCoordXBuilder(kXPrefix.length() + texCoordX->length() +
                                                kSuffix.length());
        texCoordXBuilder << kXPrefix << *texCoordX << kSuffix;
        *texCoordX = texCoordXBuilder;
        ImmutableStringBuilder texCoordYBuilder(kYPrefix.length() + texCoordX->length() +
                                                kSuffix.length());
        texCoordYBuilder << kYPrefix << *texCoordY << kSuffix;
        *texCoordY = texCoordYBuilder;
        *texCoordZ = ImmutableString("face");
    }
    else if (textureFunction.method != TextureFunctionHLSL::TextureFunction::FETCH)
    {
        if (IsSamplerArray(textureFunction.sampler))
        {
            out << "    float width; float height; float layers; float levels;\n";
            if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0)
            {
                out << "    uint mip = 0;\n";
            }
            else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0BIAS)
            {
                out << "    uint mip = bias;\n";
            }
            else
            {

                out << "    " << textureReference
                    << ".GetDimensions(baseLevel, width, height, layers, levels);\n";
                if (textureFunction.method == TextureFunctionHLSL::TextureFunction::IMPLICIT ||
                    textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                {
                    out << "    float2 tSized = float2(t.x * width, t.y * height);\n"
                           "    float dx = length(ddx(tSized));\n"
                           "    float dy = length(ddy(tSized));\n"
                           "    float lod = log2(max(dx, dy));\n";

                    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                    {
                        out << "    lod += bias;\n";
                    }
                }
                else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
                {
                    out << "    float2 sizeVec = float2(width, height);\n"
                           "    float2 sizeDdx = ddx * sizeVec;\n"
                           "    float2 sizeDdy = ddy * sizeVec;\n"
                           "    float lod = log2(max(dot(sizeDdx, sizeDdx), "
                           "dot(sizeDdy, sizeDdy))) * 0.5f;\n";
                }

                out << "    uint mip = uint(min(max(round(lod), 0), levels - 1));\n";
            }

            out << "    " << textureReference
                << ".GetDimensions(baseLevel + mip, width, height, layers, levels);\n";
        }
        else if (IsSampler2D(textureFunction.sampler))
        {
            out << "    float width; float height; float levels;\n";

            if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0)
            {
                out << "    uint mip = 0;\n";
            }
            else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0BIAS)
            {
                out << "    uint mip = bias;\n";
            }
            else
            {
                out << "    " << textureReference
                    << ".GetDimensions(baseLevel, width, height, levels);\n";

                if (textureFunction.method == TextureFunctionHLSL::TextureFunction::IMPLICIT ||
                    textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                {
                    out << "    float2 tSized = float2(t.x * width, t.y * height);\n"
                           "    float dx = length(ddx(tSized));\n"
                           "    float dy = length(ddy(tSized));\n"
                           "    float lod = log2(max(dx, dy));\n";

                    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                    {
                        out << "    lod += bias;\n";
                    }
                }
                else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
                {
                    out << "    float2 sizeVec = float2(width, height);\n"
                           "    float2 sizeDdx = ddx * sizeVec;\n"
                           "    float2 sizeDdy = ddy * sizeVec;\n"
                           "    float lod = log2(max(dot(sizeDdx, sizeDdx), "
                           "dot(sizeDdy, sizeDdy))) * 0.5f;\n";
                }

                out << "    uint mip = uint(min(max(round(lod), 0), levels - 1));\n";
            }

            out << "    " << textureReference
                << ".GetDimensions(baseLevel + mip, width, height, levels);\n";
        }
        else if (IsSampler3D(textureFunction.sampler))
        {
            out << "    float width; float height; float depth; float levels;\n";

            if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0)
            {
                out << "    uint mip = 0;\n";
            }
            else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::LOD0BIAS)
            {
                out << "    uint mip = bias;\n";
            }
            else
            {
                out << "    " << textureReference
                    << ".GetDimensions(baseLevel, width, height, depth, levels);\n";

                if (textureFunction.method == TextureFunctionHLSL::TextureFunction::IMPLICIT ||
                    textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                {
                    out << "    float3 tSized = float3(t.x * width, t.y * height, t.z * depth);\n"
                           "    float dx = length(ddx(tSized));\n"
                           "    float dy = length(ddy(tSized));\n"
                           "    float lod = log2(max(dx, dy));\n";

                    if (textureFunction.method == TextureFunctionHLSL::TextureFunction::BIAS)
                    {
                        out << "    lod += bias;\n";
                    }
                }
                else if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
                {
                    out << "    float3 sizeVec = float3(width, height, depth);\n"
                           "    float3 sizeDdx = ddx * sizeVec;\n"
                           "    float3 sizeDdy = ddy * sizeVec;\n"
                           "    float lod = log2(max(dot(sizeDdx, sizeDdx), dot(sizeDdy, "
                           "sizeDdy))) * 0.5f;\n";
                }

                out << "    uint mip = uint(min(max(round(lod), 0), levels - 1));\n";
            }

            out << "    " << textureReference
                << ".GetDimensions(baseLevel + mip, width, height, depth, levels);\n";
        }
        else
            UNREACHABLE();

        OutputIntTexCoordWraps(out, textureFunction, texCoordX, texCoordY, texCoordZ);
    }
}

void OutputTextureGatherFunctionBody(TInfoSinkBase &out,
                                     const TextureFunctionHLSL::TextureFunction &textureFunction,
                                     ShShaderOutput outputType,
                                     const ImmutableString &textureReference,
                                     const ImmutableString &samplerReference,
                                     const ImmutableString &texCoordX,
                                     const ImmutableString &texCoordY,
                                     const ImmutableString &texCoordZ)
{
    const int hlslCoords = GetHLSLCoordCount(textureFunction, outputType);
    ImmutableString samplerCoordTypeString(
        GetSamplerCoordinateTypeString(textureFunction, hlslCoords));
    ImmutableStringBuilder samplerCoordBuilder(
        samplerCoordTypeString.length() + strlen("(") + texCoordX.length() + strlen(", ") +
        texCoordY.length() + strlen(", ") + texCoordZ.length() + strlen(")"));

    samplerCoordBuilder << samplerCoordTypeString << "(" << texCoordX << ", " << texCoordY;
    if (hlslCoords >= 3)
    {
        if (textureFunction.coords < 3)
        {
            samplerCoordBuilder << ", 0";
        }
        else
        {
            samplerCoordBuilder << ", " << texCoordZ;
        }
    }
    samplerCoordBuilder << ")";

    ImmutableString samplerCoordString(samplerCoordBuilder);

    if (IsShadowSampler(textureFunction.sampler))
    {
        out << "return " << textureReference << ".GatherCmp(" << samplerReference << ", "
            << samplerCoordString << ", refZ";
        if (textureFunction.offset)
        {
            out << ", offset";
        }
        out << ");\n";
        return;
    }

    constexpr std::array<const char *, 4> kHLSLGatherFunctions = {
        {"GatherRed", "GatherGreen", "GatherBlue", "GatherAlpha"}};

    out << "    switch(comp)\n"
           "    {\n";
    for (size_t component = 0; component < kHLSLGatherFunctions.size(); ++component)
    {
        out << "        case " << component << ":\n"
            << "            return " << textureReference << "." << kHLSLGatherFunctions[component]
            << "(" << samplerReference << ", " << samplerCoordString;
        if (textureFunction.offset)
        {
            out << ", offset";
        }
        out << ");\n";
    }

    out << "        default:\n"
           "            return float4(0.0, 0.0, 0.0, 1.0);\n"
           "    }\n";
}

void OutputTextureSampleFunctionReturnStatement(
    TInfoSinkBase &out,
    const TextureFunctionHLSL::TextureFunction &textureFunction,
    const ShShaderOutput outputType,
    const ImmutableString &textureReference,
    const ImmutableString &samplerReference,
    const ImmutableString &texCoordX,
    const ImmutableString &texCoordY,
    const ImmutableString &texCoordZ)
{
    out << "    return ";

    if (IsIntegerSampler(textureFunction.sampler) && !IsSamplerCube(textureFunction.sampler) &&
        textureFunction.method != TextureFunctionHLSL::TextureFunction::FETCH)
    {
        out << " useBorderColor ? ";
        if (IsIntegerSamplerUnsigned(textureFunction.sampler))
        {
            out << "asuint";
        }
        out << "(samplerMetadata[samplerIndex].intBorderColor) : ";
    }

    // HLSL intrinsic
    if (outputType == SH_HLSL_3_0_OUTPUT)
    {
        switch (textureFunction.sampler)
        {
            case EbtSampler2D:
            case EbtSamplerVideoWEBGL:
            case EbtSamplerExternalOES:
                out << "tex2D";
                break;
            case EbtSamplerCube:
                out << "texCUBE";
                break;
            default:
                UNREACHABLE();
        }

        switch (textureFunction.method)
        {
            case TextureFunctionHLSL::TextureFunction::IMPLICIT:
                out << "(" << samplerReference << ", ";
                break;
            case TextureFunctionHLSL::TextureFunction::BIAS:
                out << "bias(" << samplerReference << ", ";
                break;
            case TextureFunctionHLSL::TextureFunction::LOD:
                out << "lod(" << samplerReference << ", ";
                break;
            case TextureFunctionHLSL::TextureFunction::LOD0:
                out << "lod(" << samplerReference << ", ";
                break;
            case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
                out << "lod(" << samplerReference << ", ";
                break;
            case TextureFunctionHLSL::TextureFunction::GRAD:
                out << "grad(" << samplerReference << ", ";
                break;
            default:
                UNREACHABLE();
        }
    }
    else if (outputType == SH_HLSL_4_1_OUTPUT || outputType == SH_HLSL_4_0_FL9_3_OUTPUT)
    {
        OutputHLSL4SampleFunctionPrefix(out, textureFunction, textureReference, samplerReference);
    }
    else
        UNREACHABLE();

    const int hlslCoords = GetHLSLCoordCount(textureFunction, outputType);
    out << GetSamplerCoordinateTypeString(textureFunction, hlslCoords);

    if (hlslCoords >= 2)
    {
        out << "(" << texCoordX << ", " << texCoordY;
    }
    else if (hlslCoords == 1)
    {
        std::string varName(texCoordX.data());
        if (size_t pos = varName.find_last_of('.') != std::string::npos)
        {
            varName = varName.substr(0, pos);
        }
        out << "(" << varName;
    }
    else
    {
        out << "(";
    }

    if (outputType == SH_HLSL_3_0_OUTPUT)
    {
        if (hlslCoords >= 3)
        {
            if (textureFunction.coords < 3)
            {
                out << ", 0";
            }
            else
            {
                out << ", " << texCoordZ;
            }
        }

        if (hlslCoords == 4)
        {
            switch (textureFunction.method)
            {
                case TextureFunctionHLSL::TextureFunction::BIAS:
                    out << ", bias";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD:
                    out << ", lod";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD0:
                    out << ", 0";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
                    out << ", bias";
                    break;
                default:
                    UNREACHABLE();
            }
        }

        out << ")";
    }
    else if (outputType == SH_HLSL_4_1_OUTPUT || outputType == SH_HLSL_4_0_FL9_3_OUTPUT)
    {
        if (hlslCoords >= 3)
        {
            ASSERT(!IsIntegerSampler(textureFunction.sampler) ||
                   !IsSamplerCube(textureFunction.sampler) || texCoordZ == "face");
            out << ", " << texCoordZ;
        }

        if (textureFunction.method == TextureFunctionHLSL::TextureFunction::GRAD)
        {
            if (IsIntegerSampler(textureFunction.sampler))
            {
                out << ", mip)";
            }
            else if (IsShadowSampler(textureFunction.sampler))
            {
                // Compare value
                if (textureFunction.proj)
                {
                    // According to ESSL 3.00.4 sec 8.8 p95 on textureProj:
                    // The resulting third component of P' in the shadow forms is used as
                    // Dref
                    out << "), " << texCoordZ;
                }
                else
                {
                    switch (textureFunction.coords)
                    {
                        case 3:
                            out << "), t.z";
                            break;
                        case 4:
                            out << "), t.w";
                            break;
                        default:
                            UNREACHABLE();
                    }
                }
            }
            else
            {
                out << "), ddx, ddy";
            }
        }
        else if (IsIntegerSampler(textureFunction.sampler) ||
                 textureFunction.method == TextureFunctionHLSL::TextureFunction::FETCH)
        {
            if (IsSampler2DMS(textureFunction.sampler) ||
                IsSampler2DMSArray(textureFunction.sampler))
                out << "), index";
            else if (IsSamplerBuffer(textureFunction.sampler))
                out << ")";
            else
                out << ", mip)";
        }
        else if (IsShadowSampler(textureFunction.sampler))
        {
            // Compare value
            if (textureFunction.proj)
            {
                // According to ESSL 3.00.4 sec 8.8 p95 on textureProj:
                // The resulting third component of P' in the shadow forms is used as Dref
                out << "), " << texCoordZ;
            }
            else
            {
                switch (textureFunction.coords)
                {
                    case 3:
                        out << "), t.z";
                        break;
                    case 4:
                        out << "), t.w";
                        break;
                    default:
                        UNREACHABLE();
                }
            }
        }
        else
        {
            switch (textureFunction.method)
            {
                case TextureFunctionHLSL::TextureFunction::IMPLICIT:
                    out << ")";
                    break;
                case TextureFunctionHLSL::TextureFunction::BIAS:
                    out << "), bias";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD:
                    out << "), lod";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD0:
                    out << "), 0";
                    break;
                case TextureFunctionHLSL::TextureFunction::LOD0BIAS:
                    out << "), bias";
                    break;
                default:
                    UNREACHABLE();
            }
        }

        if (textureFunction.offset &&
            (!IsIntegerSampler(textureFunction.sampler) ||
             textureFunction.method == TextureFunctionHLSL::TextureFunction::FETCH))
        {
            out << ", offset";
        }
    }
    else
        UNREACHABLE();

    out << ");\n";  // Close the sample function call and return statement
}

}  // Anonymous namespace

ImmutableString TextureFunctionHLSL::TextureFunction::name() const
{
    static const ImmutableString kGlTextureName("gl_texture");

    ImmutableString suffix(TextureTypeSuffix(this->sampler));

    ImmutableStringBuilder name(kGlTextureName.length() + suffix.length() + 4u + 6u + 5u);

    name << kGlTextureName;

    // We need to include full the sampler type in the function name to make the signature unique
    // on D3D11, where samplers are passed to texture functions as indices.
    name << suffix;

    if (proj)
    {
        name << "Proj";
    }

    if (offset)
    {
        name << "Offset";
    }

    switch (method)
    {
        case IMPLICIT:
            break;
        case BIAS:
            break;  // Extra parameter makes the signature unique
        case LOD:
            name << "Lod";
            break;
        case LOD0:
            name << "Lod0";
            break;
        case LOD0BIAS:
            name << "Lod0";
            break;  // Extra parameter makes the signature unique
        case SIZE:
            name << "Size";
            break;
        case FETCH:
            name << "Fetch";
            break;
        case GRAD:
            name << "Grad";
            break;
        case GATHER:
            name << "Gather";
            break;
        default:
            UNREACHABLE();
    }

    return name;
}

const char *TextureFunctionHLSL::TextureFunction::getReturnType() const
{
    if (method == TextureFunction::SIZE)
    {
        switch (sampler)
        {
            case EbtSampler2D:
            case EbtISampler2D:
            case EbtUSampler2D:
            case EbtSampler2DShadow:
            case EbtSamplerCube:
            case EbtISamplerCube:
            case EbtUSamplerCube:
            case EbtSamplerCubeShadow:
            case EbtSamplerExternalOES:
            case EbtSampler2DMS:
            case EbtISampler2DMS:
            case EbtUSampler2DMS:
            case EbtSamplerVideoWEBGL:
                return "int2";
            case EbtSampler3D:
            case EbtISampler3D:
            case EbtUSampler3D:
            case EbtSampler2DArray:
            case EbtISampler2DArray:
            case EbtUSampler2DArray:
            case EbtSampler2DMSArray:
            case EbtISampler2DMSArray:
            case EbtUSampler2DMSArray:
            case EbtSampler2DArrayShadow:
                return "int3";
            case EbtISamplerBuffer:
            case EbtUSamplerBuffer:
            case EbtSamplerBuffer:
                return "int";
            default:
                UNREACHABLE();
        }
    }
    else  // Sampling function
    {
        switch (sampler)
        {
            case EbtSampler2D:
            case EbtSampler2DMS:
            case EbtSampler2DMSArray:
            case EbtSampler3D:
            case EbtSamplerCube:
            case EbtSampler2DArray:
            case EbtSamplerExternalOES:
            case EbtSamplerVideoWEBGL:
            case EbtSamplerBuffer:
                return "float4";
            case EbtISampler2D:
            case EbtISampler2DMS:
            case EbtISampler2DMSArray:
            case EbtISampler3D:
            case EbtISamplerCube:
            case EbtISampler2DArray:
            case EbtISamplerBuffer:
                return "int4";
            case EbtUSampler2D:
            case EbtUSampler2DMS:
            case EbtUSampler2DMSArray:
            case EbtUSampler3D:
            case EbtUSamplerCube:
            case EbtUSampler2DArray:
            case EbtUSamplerBuffer:
                return "uint4";
            case EbtSampler2DShadow:
            case EbtSamplerCubeShadow:
            case EbtSampler2DArrayShadow:
                if (method == TextureFunctionHLSL::TextureFunction::GATHER)
                {
                    return "float4";
                }
                else
                {
                    return "float";
                }
            default:
                UNREACHABLE();
        }
    }
    return "";
}

bool TextureFunctionHLSL::TextureFunction::operator<(const TextureFunction &rhs) const
{
    return std::tie(sampler, coords, proj, offset, method) <
           std::tie(rhs.sampler, rhs.coords, rhs.proj, rhs.offset, rhs.method);
}

ImmutableString TextureFunctionHLSL::useTextureFunction(const ImmutableString &name,
                                                        TBasicType samplerType,
                                                        int coords,
                                                        size_t argumentCount,
                                                        bool lod0,
                                                        sh::GLenum shaderType)
{
    TextureFunction textureFunction;
    textureFunction.sampler = samplerType;
    textureFunction.coords  = coords;
    textureFunction.method  = TextureFunction::IMPLICIT;
    textureFunction.proj    = false;
    textureFunction.offset  = false;

    if (name == "texture2D" || name == "textureCube" || name == "texture")
    {
        textureFunction.method = TextureFunction::IMPLICIT;
    }
    else if (name == "texture2DProj" || name == "textureProj")
    {
        textureFunction.method = TextureFunction::IMPLICIT;
        textureFunction.proj   = true;
    }
    else if (name == "texture2DLod" || name == "textureCubeLod" || name == "textureLod" ||
             name == "texture2DLodEXT" || name == "textureCubeLodEXT")
    {
        textureFunction.method = TextureFunction::LOD;
    }
    else if (name == "texture2DProjLod" || name == "textureProjLod" ||
             name == "texture2DProjLodEXT")
    {
        textureFunction.method = TextureFunction::LOD;
        textureFunction.proj   = true;
    }
    else if (name == "textureSize")
    {
        textureFunction.method = TextureFunction::SIZE;
    }
    else if (name == "textureOffset")
    {
        textureFunction.method = TextureFunction::IMPLICIT;
        textureFunction.offset = true;
    }
    else if (name == "textureProjOffset")
    {
        textureFunction.method = TextureFunction::IMPLICIT;
        textureFunction.offset = true;
        textureFunction.proj   = true;
    }
    else if (name == "textureLodOffset")
    {
        textureFunction.method = TextureFunction::LOD;
        textureFunction.offset = true;
    }
    else if (name == "textureProjLodOffset")
    {
        textureFunction.method = TextureFunction::LOD;
        textureFunction.proj   = true;
        textureFunction.offset = true;
    }
    else if (name == "texelFetch")
    {
        textureFunction.method = TextureFunction::FETCH;
    }
    else if (name == "texelFetchOffset")
    {
        textureFunction.method = TextureFunction::FETCH;
        textureFunction.offset = true;
    }
    else if (name == "textureGrad" || name == "texture2DGradEXT")
    {
        textureFunction.method = TextureFunction::GRAD;
    }
    else if (name == "textureGradOffset")
    {
        textureFunction.method = TextureFunction::GRAD;
        textureFunction.offset = true;
    }
    else if (name == "textureProjGrad" || name == "texture2DProjGradEXT" ||
             name == "textureCubeGradEXT")
    {
        textureFunction.method = TextureFunction::GRAD;
        textureFunction.proj   = true;
    }
    else if (name == "textureProjGradOffset")
    {
        textureFunction.method = TextureFunction::GRAD;
        textureFunction.proj   = true;
        textureFunction.offset = true;
    }
    else if (name == "textureGather")
    {
        textureFunction.method = TextureFunction::GATHER;
    }
    else if (name == "textureGatherOffset")
    {
        textureFunction.method = TextureFunction::GATHER;
        textureFunction.offset = true;
    }
    else if (name == "textureVideoWEBGL")
    {
        textureFunction.method = TextureFunction::IMPLICIT;
    }
    else
        UNREACHABLE();

    if (textureFunction.method ==
        TextureFunction::IMPLICIT)  // Could require lod 0 or have a bias argument
    {
        size_t mandatoryArgumentCount = 2;  // All functions have sampler and coordinate arguments

        if (textureFunction.offset)
        {
            mandatoryArgumentCount++;
        }

        bool bias = (argumentCount > mandatoryArgumentCount);  // Bias argument is optional

        if (lod0 || shaderType == GL_VERTEX_SHADER || shaderType == GL_COMPUTE_SHADER)
        {
            if (bias)
            {
                textureFunction.method = TextureFunction::LOD0BIAS;
            }
            else
            {
                textureFunction.method = TextureFunction::LOD0;
            }
        }
        else if (bias)
        {
            textureFunction.method = TextureFunction::BIAS;
        }
    }

    mUsesTexture.insert(textureFunction);
    return textureFunction.name();
}

void TextureFunctionHLSL::textureFunctionHeader(TInfoSinkBase &out,
                                                const ShShaderOutput outputType,
                                                bool getDimensionsIgnoresBaseLevel)
{
    for (const TextureFunction &textureFunction : mUsesTexture)
    {
        // Function header
        out << textureFunction.getReturnType() << " " << textureFunction.name() << "(";

        OutputTextureFunctionArgumentList(out, textureFunction, outputType);

        out << ")\n"
               "{\n";

        // In some cases we use a variable to store the texture/sampler objects, but to work around
        // a D3D11 compiler bug related to discard inside a loop that is conditional on texture
        // sampling we need to call the function directly on references to the texture and sampler
        // arrays. The bug was found using dEQP-GLES3.functional.shaders.discard*loop_texture*
        // tests.
        ImmutableString textureReference("");
        ImmutableString samplerReference("");
        GetTextureReference(out, textureFunction, outputType, &textureReference, &samplerReference);

        if (textureFunction.method == TextureFunction::SIZE)
        {
            OutputTextureSizeFunctionBody(out, textureFunction, textureReference,
                                          getDimensionsIgnoresBaseLevel);
        }
        else
        {
            ImmutableString texCoordX("t.x");
            ImmutableString texCoordY("t.y");
            ImmutableString texCoordZ("t.z");
            if (textureFunction.method == TextureFunction::GATHER)
            {
                OutputTextureGatherFunctionBody(out, textureFunction, outputType, textureReference,
                                                samplerReference, texCoordX, texCoordY, texCoordZ);
            }
            else
            {
                ProjectTextureCoordinates(textureFunction, &texCoordX, &texCoordY, &texCoordZ);
                OutputIntegerTextureSampleFunctionComputations(
                    out, textureFunction, outputType, textureReference, &texCoordX, &texCoordY,
                    &texCoordZ, getDimensionsIgnoresBaseLevel);
                OutputTextureSampleFunctionReturnStatement(out, textureFunction, outputType,
                                                           textureReference, samplerReference,
                                                           texCoordX, texCoordY, texCoordZ);
            }
        }

        out << "}\n"
               "\n";
    }
}

}  // namespace sh