Fix minor issues with ANGLE_texture_rectangle.

src/libANGLE/Caps.cpp

@@ -853,7 +853,7 @@ Caps::Caps()
     }
 }
 
-Caps GenerateMinimumCaps(const Version &clientVersion)
+Caps GenerateMinimumCaps(const Version &clientVersion, const Extensions &extensions)
 {
     Caps caps;
 
@@ -1040,6 +1040,11 @@ Caps GenerateMinimumCaps(const Version &clientVersion)
         caps.shaderStorageBufferOffsetAlignment = 256;
     }
 
+    if (extensions.textureRectangle)
+    {
+        caps.maxRectangleTextureSize = 64;
+    }
+
     return caps;
 }
 }

src/libANGLE/Caps.h

@@ -547,7 +547,7 @@ struct Caps
     GLuint maxSamples;
 };
 
-Caps GenerateMinimumCaps(const Version &clientVersion);
+Caps GenerateMinimumCaps(const Version &clientVersion, const Extensions &extensions);
 }
 
 namespace egl

src/libANGLE/Context.cpp

@@ -343,14 +343,15 @@ Context::Context(rx::EGLImplFactory *implFactory,
         }
     }
 
-    if (mExtensions.textureRectangle)
+    const Extensions &nativeExtensions = mImplementation->getNativeExtensions();
+    if (nativeExtensions.textureRectangle)
     {
         Texture *zeroTextureRectangle =
             new Texture(mImplementation.get(), 0, GL_TEXTURE_RECTANGLE_ANGLE);
         mZeroTextures[GL_TEXTURE_RECTANGLE_ANGLE].set(this, zeroTextureRectangle);
     }
 
-    if (mExtensions.eglImageExternal || mExtensions.eglStreamConsumerExternal)
+    if (nativeExtensions.eglImageExternal || nativeExtensions.eglStreamConsumerExternal)
     {
         Texture *zeroTextureExternal =
             new Texture(mImplementation.get(), 0, GL_TEXTURE_EXTERNAL_OES);

src/libANGLE/State.cpp

@@ -23,6 +23,7 @@
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/queryconversions.h"
+#include "libANGLE/renderer/ContextImpl.h"
 
 namespace
 {
@@ -84,6 +85,7 @@ void State::initialize(const Context *context,
 {
     const Caps &caps             = context->getCaps();
     const Extensions &extensions = context->getExtensions();
+    const Extensions &nativeExtensions = context->getImplementation()->getNativeExtensions();
     const Version &clientVersion = context->getClientVersion();
 
     mMaxDrawBuffers = caps.maxDrawBuffers;
@@ -158,11 +160,11 @@ void State::initialize(const Context *context,
         mShaderStorageBuffers.resize(caps.maxShaderStorageBufferBindings);
         mImageUnits.resize(caps.maxImageUnits);
     }
-    if (extensions.textureRectangle)
+    if (nativeExtensions.textureRectangle)
     {
         mSamplerTextures[GL_TEXTURE_RECTANGLE_ANGLE].resize(caps.maxCombinedTextureImageUnits);
     }
-    if (extensions.eglImageExternal || extensions.eglStreamConsumerExternal)
+    if (nativeExtensions.eglImageExternal || nativeExtensions.eglStreamConsumerExternal)
     {
         mSamplerTextures[GL_TEXTURE_EXTERNAL_OES].resize(caps.maxCombinedTextureImageUnits);
     }

src/libANGLE/angletypes.cpp

@@ -143,9 +143,9 @@ SamplerState SamplerState::CreateDefaultForTarget(GLenum target)
 {
     SamplerState state;
 
-    // According to OES_EGL_image_external: For external textures, the default min filter is
-    // GL_LINEAR and the default s and t wrap modes are GL_CLAMP_TO_EDGE.
-    if (target == GL_TEXTURE_EXTERNAL_OES)
+    // According to OES_EGL_image_external and ARB_texture_rectangle: For external textures, the
+    // default min filter is GL_LINEAR and the default s and t wrap modes are GL_CLAMP_TO_EDGE.
+    if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ANGLE)
     {
         state.minFilter = GL_LINEAR;
         state.wrapS     = GL_CLAMP_TO_EDGE;

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -64,9 +64,6 @@ ContextNULL::ContextNULL(const gl::ContextState &state, AllocationTrackerNULL *a
 {
     ASSERT(mAllocationTracker != nullptr);
 
-    const gl::Version maxClientVersion(3, 1);
-    mCaps = GenerateMinimumCaps(maxClientVersion);
-
     mExtensions                       = gl::Extensions();
     mExtensions.fence                 = true;
     mExtensions.instancedArrays       = true;
@@ -75,9 +72,13 @@ ContextNULL::ContextNULL(const gl::ContextState &state, AllocationTrackerNULL *a
     mExtensions.mapBufferRange        = true;
     mExtensions.copyTexture           = true;
     mExtensions.copyCompressedTexture = true;
+    mExtensions.textureRectangle      = true;
 
     mExtensions.rgb8rgba8 = true;
 
+    const gl::Version maxClientVersion(3, 1);
+    mCaps = GenerateMinimumCaps(maxClientVersion, mExtensions);
+
     mTextureCaps = GenerateMinimumTextureCapsMap(maxClientVersion, mExtensions);
 }
 

src/tests/gl_tests/TextureRectangleTest.cpp

@@ -340,6 +340,26 @@ TEST_P(TextureRectangleTest, RenderToRectangle)
     ASSERT_GL_NO_ERROR();
 }
 
+TEST_P(TextureRectangleTest, DefaultSamplerParameters)
+{
+    ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
+
+    GLTexture tex;
+    glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
+
+    GLint minFilter = 0;
+    glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, &minFilter);
+    EXPECT_EQ(GL_LINEAR, minFilter);
+
+    GLint wrapS = 0;
+    glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, &wrapS);
+    EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapS);
+
+    GLint wrapT = 0;
+    glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, &wrapT);
+    EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapT);
+}
+
 // Test glCopyTexImage with rectangle textures
 TEST_P(TextureRectangleTestES3, CopyTexImage)
 {

src/tests/gl_tests/WebGLCompatibilityTest.cpp

@@ -778,6 +778,34 @@ TEST_P(WebGLCompatibilityTest, EnablePackUnpackSubImageExtension)
     }
 }
 
+TEST_P(WebGLCompatibilityTest, EnableTextureRectangle)
+{
+    EXPECT_FALSE(extensionEnabled("GL_ANGLE_texture_rectangle"));
+
+    GLTexture texture;
+    glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, texture);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    GLint minFilter = 0;
+    glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, &minFilter);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    if (extensionRequestable("GL_ANGLE_texture_rectangle"))
+    {
+        glRequestExtensionANGLE("GL_ANGLE_texture_rectangle");
+        EXPECT_GL_NO_ERROR();
+
+        EXPECT_TRUE(extensionEnabled("GL_ANGLE_texture_rectangle"));
+
+        glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, texture);
+        EXPECT_GL_NO_ERROR();
+
+        glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                     nullptr);
+        EXPECT_GL_NO_ERROR();
+    }
+}
+
 // Test enabling the GL_NV_pack_subimage extension
 TEST_P(WebGLCompatibilityTest, EnablePackPackSubImageExtension)
 {