Fix texture buffer unbind and size query

src/libANGLE/Context.cpp

@@ -2099,8 +2099,11 @@ void Context::getRenderbufferParameterivRobust(GLenum target,
 
 void Context::texBuffer(TextureType target, GLenum internalformat, BufferID buffer)
 {
+    ASSERT(target == TextureType::Buffer);
+
+    Texture *texture  = getTextureByType(target);
     Buffer *bufferObj = mState.mBufferManager->getBuffer(buffer);
-    texBufferRange(target, internalformat, buffer, 0, clampCast<GLintptr>(bufferObj->getSize()));
+    ANGLE_CONTEXT_TRY(texture->setBuffer(this, bufferObj, internalformat));
 }
 
 void Context::texBufferRange(TextureType target,
@@ -2113,7 +2116,7 @@ void Context::texBufferRange(TextureType target,
 
     Texture *texture  = getTextureByType(target);
     Buffer *bufferObj = mState.mBufferManager->getBuffer(buffer);
-    ANGLE_CONTEXT_TRY(texture->setBuffer(this, bufferObj, internalformat, offset, size));
+    ANGLE_CONTEXT_TRY(texture->setBufferRange(this, bufferObj, internalformat, offset, size));
 }
 
 void Context::getTexParameterfv(TextureType target, GLenum pname, GLfloat *params)

src/libANGLE/Texture.cpp

@@ -1896,16 +1896,32 @@ GLenum Texture::getGenerateMipmapHint() const
 
 angle::Result Texture::setBuffer(const gl::Context *context,
                                  gl::Buffer *buffer,
-                                 GLenum internalFormat,
-                                 GLintptr offset,
-                                 GLsizeiptr size)
+                                 GLenum internalFormat)
+{
+    // Use UINT_MAX to indicate that the size is taken from whatever size the buffer has when the
+    // texture buffer is used.
+    return setBufferRange(context, buffer, internalFormat, 0,
+                          std::numeric_limits<GLsizeiptr>::max());
+}
+
+angle::Result Texture::setBufferRange(const gl::Context *context,
+                                      gl::Buffer *buffer,
+                                      GLenum internalFormat,
+                                      GLintptr offset,
+                                      GLsizeiptr size)
 {
     mState.mImmutableFormat = true;
     mState.mBuffer.set(context, buffer, offset, size);
     ANGLE_TRY(mTexture->setBuffer(context, internalFormat));
 
-    mState.mImmutableLevels = static_cast<GLuint>(1);
     mState.clearImageDescs();
+    if (buffer == nullptr)
+    {
+        signalDirtyStorage(InitState::MayNeedInit);
+        return angle::Result::Continue;
+    }
+
+    mState.mImmutableLevels           = static_cast<GLuint>(1);
     InternalFormat internalFormatInfo = GetSizedInternalFormatInfo(internalFormat);
     Format format(internalFormat);
     Extents extents(static_cast<GLuint>(size / internalFormatInfo.pixelBytes), 1, 1);

src/libANGLE/Texture.h

@@ -329,11 +329,12 @@ class Texture final : public RefCountObject<TextureID>,
     void setBorderColor(const Context *context, const ColorGeneric &color);
     const ColorGeneric &getBorderColor() const;
 
-    angle::Result setBuffer(const Context *context,
-                            gl::Buffer *buffer,
-                            GLenum internalFormat,
-                            GLintptr offset,
-                            GLsizeiptr size);
+    angle::Result setBuffer(const Context *context, gl::Buffer *buffer, GLenum internalFormat);
+    angle::Result setBufferRange(const Context *context,
+                                 gl::Buffer *buffer,
+                                 GLenum internalFormat,
+                                 GLintptr offset,
+                                 GLsizeiptr size);
     const OffsetBindingPointer<Buffer> &getBuffer() const;
 
     const TextureState &getTextureState() const;

src/libANGLE/queryutils.cpp

@@ -226,9 +226,20 @@ void QueryTexLevelParameterBase(const Texture *texture,
                 pname, static_cast<GLint>(texture->getBuffer().getOffset()));
             break;
         case GL_TEXTURE_BUFFER_SIZE:
-            *params = CastFromStateValue<ParamType>(
-                pname, static_cast<GLint>(texture->getBuffer().getSize()));
-            break;
+        {
+            const OffsetBindingPointer<Buffer> &bufferBinding = texture->getBuffer();
+            Buffer *buffer                                    = bufferBinding.get();
+            GLsizeiptr size                                   = bufferBinding.getSize();
+            const GLintptr offset                             = bufferBinding.getOffset();
+
+            if (buffer != nullptr)
+            {
+                size = std::min(size, static_cast<GLsizeiptr>(buffer->getSize()) - offset);
+            }
+
+            *params = CastFromStateValue<ParamType>(pname, static_cast<GLint>(size));
+        }
+        break;
         default:
             UNREACHABLE();
             break;

src/libANGLE/renderer/gl/TextureGL.cpp

@@ -1724,11 +1724,25 @@ angle::Result TextureGL::setSwizzle(const gl::Context *context, GLint swizzle[4]
 
 angle::Result TextureGL::setBuffer(const gl::Context *context, GLenum internalFormat)
 {
-    const FunctionsGL *functions = GetFunctionsGL(context);
-    const BufferGL *bufferGL     = GetImplAs<BufferGL>(mState.mBuffer.get());
-    ANGLE_GL_TRY(context, functions->texBufferRange(
-                              GL_TEXTURE_BUFFER, internalFormat, bufferGL->getBufferID(),
-                              mState.mBuffer.getOffset(), mState.mBuffer.getSize()));
+    const FunctionsGL *functions                              = GetFunctionsGL(context);
+    const gl::OffsetBindingPointer<gl::Buffer> &bufferBinding = mState.mBuffer;
+    const gl::Buffer *buffer                                  = bufferBinding.get();
+    const GLintptr offset                                     = bufferBinding.getOffset();
+    const GLsizeiptr size                                     = bufferBinding.getSize();
+    const GLuint bufferID = buffer ? GetImplAs<BufferGL>(buffer)->getBufferID() : 0;
+
+    // If buffer is not bound, use texBuffer to unbind it.  If size is UINT_MAX, texBuffer was used
+    // to create this binding, so use the same function.  This will allow the implementation to take
+    // the current size of the buffer on every draw/dispatch call even if the buffer size changes.
+    if (buffer == nullptr || size == std::numeric_limits<GLsizeiptr>::max())
+    {
+        ANGLE_GL_TRY(context, functions->texBuffer(GL_TEXTURE_BUFFER, internalFormat, bufferID));
+    }
+    else
+    {
+        ANGLE_GL_TRY(context, functions->texBufferRange(GL_TEXTURE_BUFFER, internalFormat, bufferID,
+                                                        offset, size));
+    }
 
     return angle::Result::Continue;
 }

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -4,6 +4,8 @@
 
 // See README.md for format.
 
+3573 : dEQP-GLES31.functional.state_query.texture_level.texture_buffer.width_* = FAIL
+
 ////
 //// Desktop expectations
 ////