tor-browser

TextureFunctionHLSL.cpp (61161B)

---

//
// 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