Wrap integer textures with correct wrap mode in HLSL

src/compiler/translator/OutputHLSL.cpp

@@ -74,6 +74,42 @@ const TConstantUnion *WriteConstantUnionArray(TInfoSinkBase &out,
     return constUnionIterated;
 }
 
+void OutputIntTexCoordWrap(TInfoSinkBase &out,
+                           const char *wrapMode,
+                           const char *size,
+                           const TString &texCoord,
+                           const TString &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";
+
+    // CLAMP_TO_EDGE
+    out << "if (" << wrapMode << " == 1)\n";
+    out << "{\n";
+    out << "    " << texCoordOutName << " = clamp(int(floor(" << size << " * " << texCoordOutName
+        << "Offset)), 0, int(" << size << ") - 1);\n";
+    out << "}\n";
+
+    // MIRRORED_REPEAT
+    out << "else if (" << wrapMode << " == 3)\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";
+}
+
 } // namespace
 
 namespace sh
@@ -864,7 +900,7 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
 
         if (textureFunction->method == TextureFunction::SIZE)
         {
-            out << "int baseLevel = samplerMetadata[samplerIndex].x;\n";
+            out << "int baseLevel = samplerMetadata[samplerIndex].baseLevel;\n";
             if (IsSampler2D(textureFunction->sampler) || IsSamplerCube(textureFunction->sampler))
             {
                 if (IsSamplerArray(textureFunction->sampler) ||
@@ -1169,8 +1205,26 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
                 else UNREACHABLE();
 
                 // Convert from normalized floating-point to integer
-                texCoordX = "int(floor(width * frac(" + texCoordX + ")))";
-                texCoordY = "int(floor(height * frac(" + texCoordY + ")))";
+                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 = "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 = "tiy";
 
                 if (IsSamplerArray(textureFunction->sampler))
                 {
@@ -1179,7 +1233,16 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
                 else if (!IsSamplerCube(textureFunction->sampler) &&
                          !IsSampler2D(textureFunction->sampler))
                 {
-                    texCoordZ = "int(floor(depth * frac(" + texCoordZ + ")))";
+                    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 = "tiz";
                 }
             }
 
@@ -1421,7 +1484,8 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
                     }
                 }
 
-                if (textureFunction->offset)
+                if (textureFunction->offset && (!IsIntegerSampler(textureFunction->sampler) ||
+                                                textureFunction->method == TextureFunction::FETCH))
                 {
                     out << ", offset";
                 }

src/compiler/translator/UniformHLSL.cpp

@@ -337,8 +337,15 @@ void UniformHLSL::samplerMetadataUniforms(TInfoSinkBase &out, const char *reg)
     // If mSamplerRegister is 0 the shader doesn't use any textures.
     if (mSamplerRegister > 0)
     {
-        out << "    int4 samplerMetadata[" << mSamplerRegister << "] : packoffset(" << reg
-            << ");\n";
+        out << "    struct SamplerMetadata\n"
+               "    {\n"
+               "        int baseLevel;\n"
+               "        int internalFormatBits;\n"
+               "        int wrapModes;\n"
+               "        int padding;\n"
+               "    };\n"
+               "    SamplerMetadata samplerMetadata["
+            << mSamplerRegister << "] : packoffset(" << reg << ");\n";
     }
 }
 

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -362,6 +362,22 @@ void GetTriFanIndices(const GLvoid *indices,
     }
 }
 
+int GetWrapBits(GLenum wrap)
+{
+    switch (wrap)
+    {
+        case GL_CLAMP_TO_EDGE:
+            return 0x1;
+        case GL_REPEAT:
+            return 0x2;
+        case GL_MIRRORED_REPEAT:
+            return 0x3;
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
 }  // anonymous namespace
 
 Renderer11::Renderer11(egl::Display *display)
@@ -1213,8 +1229,7 @@ gl::Error Renderer11::setSamplerState(gl::SamplerType type,
     else UNREACHABLE();
 
     ASSERT(metadata != nullptr);
-    metadata->update(index, texture->getBaseLevel(),
-                     texture->getInternalFormat(texture->getTarget(), texture->getBaseLevel()));
+    metadata->update(index, *texture);
 
     return gl::Error(GL_NO_ERROR);
 }
@@ -2354,21 +2369,21 @@ void Renderer11::SamplerMetadataD3D11::initData(unsigned int samplerCount)
     mSamplerMetadata.resize(samplerCount);
 }
 
-void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex,
-                                              unsigned int baseLevel,
-                                              GLenum internalFormat)
+void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex, const gl::Texture &texture)
 {
-    if (mSamplerMetadata[samplerIndex].parameters[0] != static_cast<int>(baseLevel))
+    unsigned int baseLevel = texture.getBaseLevel();
+    GLenum internalFormat = texture.getInternalFormat(texture.getTarget(), texture.getBaseLevel());
+    if (mSamplerMetadata[samplerIndex].baseLevel != static_cast<int>(baseLevel))
     {
-        mSamplerMetadata[samplerIndex].parameters[0] = static_cast<int>(baseLevel);
-        mDirty                                       = true;
+        mSamplerMetadata[samplerIndex].baseLevel = static_cast<int>(baseLevel);
+        mDirty                                   = true;
     }
 
-    // internalFormatBits == 0 means a 32-bit texture in the case of integer textures. In the case
-    // of non-integer textures, internalFormatBits is meaningless. We avoid updating the constant
-    // buffer unnecessarily by changing the data only in case the texture is an integer texture and
-    // the value has changed.
-    bool needInternalFormatBits = false;
+    // Some metadata is needed only for integer textures. We avoid updating the constant buffer
+    // unnecessarily by changing the data only in case the texture is an integer texture and
+    // the values have changed.
+    bool needIntegerTextureMetadata = false;
+    // internalFormatBits == 0 means a 32-bit texture in the case of integer textures.
     int internalFormatBits = 0;
     switch (internalFormat)
     {
@@ -2380,7 +2395,7 @@ void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex,
         case GL_RG32UI:
         case GL_R32I:
         case GL_R32UI:
-            needInternalFormatBits = true;
+            needIntegerTextureMetadata = true;
             break;
         case GL_RGBA16I:
         case GL_RGBA16UI:
@@ -2390,7 +2405,7 @@ void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex,
         case GL_RG16UI:
         case GL_R16I:
         case GL_R16UI:
-            needInternalFormatBits = true;
+            needIntegerTextureMetadata = true;
             internalFormatBits     = 16;
             break;
         case GL_RGBA8I:
@@ -2401,21 +2416,34 @@ void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex,
         case GL_RG8UI:
         case GL_R8I:
         case GL_R8UI:
-            needInternalFormatBits = true;
+            needIntegerTextureMetadata = true;
             internalFormatBits     = 8;
             break;
         case GL_RGB10_A2UI:
-            needInternalFormatBits = true;
+            needIntegerTextureMetadata = true;
             internalFormatBits     = 10;
             break;
         default:
             break;
     }
-    if (needInternalFormatBits &&
-        mSamplerMetadata[samplerIndex].parameters[1] != internalFormatBits)
+    if (needIntegerTextureMetadata)
     {
-        mSamplerMetadata[samplerIndex].parameters[1] = internalFormatBits;
-        mDirty                                       = true;
+        if (mSamplerMetadata[samplerIndex].internalFormatBits != internalFormatBits)
+        {
+            mSamplerMetadata[samplerIndex].internalFormatBits = internalFormatBits;
+            mDirty                                            = true;
+        }
+        // Pack the wrap values into one integer so we can fit all the metadata in one 4-integer
+        // vector.
+        GLenum wrapS  = texture.getWrapS();
+        GLenum wrapT  = texture.getWrapT();
+        GLenum wrapR  = texture.getWrapR();
+        int wrapModes = GetWrapBits(wrapS) | (GetWrapBits(wrapT) << 2) | (GetWrapBits(wrapR) << 4);
+        if (mSamplerMetadata[samplerIndex].wrapModes != wrapModes)
+        {
+            mSamplerMetadata[samplerIndex].wrapModes = wrapModes;
+            mDirty                                   = true;
+        }
     }
 }
 

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -350,11 +350,16 @@ class Renderer11 : public RendererD3D
 
         struct dx_SamplerMetadata
         {
-            int parameters[4];
+            int baseLevel;
+            int internalFormatBits;
+            int wrapModes;
+            int padding;  // This just pads the struct to 16 bytes
         };
+        static_assert(sizeof(dx_SamplerMetadata) == 16u,
+                      "Sampler metadata struct must be one 4-vec / 16 bytes.");
 
         void initData(unsigned int samplerCount);
-        void update(unsigned int samplerIndex, unsigned int baseLevel, GLenum internalFormat);
+        void update(unsigned int samplerIndex, const gl::Texture &texture);
 
         const dx_SamplerMetadata *getData() const;
         size_t sizeBytes() const;