GLES1: glMultiTexCoord4(f|x)

src/libANGLE/Context.cpp

@@ -6400,6 +6400,10 @@ bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *nu
                 *type      = GL_FLOAT;
                 *numParams = 3;
                 return true;
+            case GL_CURRENT_TEXTURE_COORDS:
+                *type      = GL_FLOAT;
+                *numParams = 4;
+                return true;
         }
     }
 

src/libANGLE/Context_gles_1_0.cpp

@@ -279,12 +279,17 @@ void Context::multMatrixx(const GLfixed *m)
 
 void Context::multiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    UNIMPLEMENTED();
+    unsigned int unit = target - GL_TEXTURE0;
+    ASSERT(target >= GL_TEXTURE0 && unit < getCaps().maxMultitextureUnits);
+    mGLState.gles1().setCurrentTextureCoords(unit, {s, t, r, q});
 }
 
-void Context::multiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+void Context::multiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 {
-    UNIMPLEMENTED();
+    unsigned int unit = target - GL_TEXTURE0;
+    ASSERT(target >= GL_TEXTURE0 && unit < getCaps().maxMultitextureUnits);
+    mGLState.gles1().setCurrentTextureCoords(
+        unit, {FixedToFloat(s), FixedToFloat(t), FixedToFloat(r), FixedToFloat(q)});
 }
 
 void Context::normal3f(GLfloat nx, GLfloat ny, GLfloat nz)

src/libANGLE/GLES1State.cpp

@@ -14,6 +14,17 @@
 namespace gl
 {
 
+TextureCoordF::TextureCoordF() = default;
+
+TextureCoordF::TextureCoordF(float _s, float _t, float _r, float _q) : s(_s), t(_t), r(_r), q(_q)
+{
+}
+
+bool TextureCoordF::operator==(const TextureCoordF &other) const
+{
+    return s == other.s && t == other.t && r == other.r && q == other.q;
+}
+
 GLES1State::GLES1State()
     : mVertexArrayEnabled(false),
       mNormalArrayEnabled(false),
@@ -179,4 +190,14 @@ const angle::Vector3 &GLES1State::getCurrentNormal() const
     return mCurrentNormal;
 }
 
+void GLES1State::setCurrentTextureCoords(unsigned int unit, const TextureCoordF &coords)
+{
+    mCurrentTextureCoords[unit] = coords;
+}
+
+const TextureCoordF &GLES1State::getCurrentTextureCoords(unsigned int unit) const
+{
+    return mCurrentTextureCoords[unit];
+}
+
 }  // namespace gl

src/libANGLE/GLES1State.h

@@ -23,6 +23,10 @@ namespace gl
 // State types specific to GLES1 contexts, from the OpenGL ES 1.1 spec "State Tables" section
 struct TextureCoordF
 {
+    TextureCoordF();
+    TextureCoordF(float _s, float _t, float _r, float _q);
+    bool operator==(const TextureCoordF &other) const;
+
     GLfloat s = 0.0f;
     GLfloat t = 0.0f;
     GLfloat r = 0.0f;
@@ -128,6 +132,9 @@ class GLES1State final : angle::NonCopyable
     void setCurrentNormal(const angle::Vector3 &normal);
     const angle::Vector3 &getCurrentNormal() const;
 
+    void setCurrentTextureCoords(unsigned int unit, const TextureCoordF &coords);
+    const TextureCoordF &getCurrentTextureCoords(unsigned int unit) const;
+
   private:
     friend class State;
 

src/libANGLE/State.cpp

@@ -1947,6 +1947,15 @@ void State::getFloatv(GLenum pname, GLfloat *params)
             params[2]          = normal[2];
             break;
         }
+        case GL_CURRENT_TEXTURE_COORDS:
+        {
+            const auto &texcoord = mGLES1State.mCurrentTextureCoords[mActiveSampler];
+            params[0]            = texcoord.s;
+            params[1]            = texcoord.t;
+            params[2]            = texcoord.r;
+            params[3]            = texcoord.q;
+            break;
+        }
         default:
             UNREACHABLE();
             break;

src/libANGLE/validationES.cpp

@@ -90,8 +90,8 @@ bool ValidateDrawAttribs(Context *context, GLint primcount, GLint maxVertex, GLi
 
         // If we have no buffer, then we either get an error, or there are no more checks to be
         // done.
-        const VertexBinding &binding  = vertexBindings[attrib.bindingIndex];
-        gl::Buffer *buffer            = binding.getBuffer().get();
+        const VertexBinding &binding = vertexBindings[attrib.bindingIndex];
+        gl::Buffer *buffer           = binding.getBuffer().get();
         if (!buffer)
         {
             if (webglCompatibility || !state.areClientArraysEnabled())
@@ -477,7 +477,7 @@ bool ValidateFragmentShaderColorBufferTypeMatch(Context *context)
 
 bool ValidateVertexShaderAttributeTypeMatch(Context *context)
 {
-    const auto &glState       = context->getGLState();
+    const auto &glState    = context->getGLState();
     const Program *program = context->getGLState().getProgram();
     const VertexArray *vao = context->getGLState().getVertexArray();
 
@@ -1333,7 +1333,7 @@ bool ValidateBlitFramebufferParameters(Context *context,
                     GLenum drawComponentType = drawFormat.info->componentType;
                     bool readFixedPoint      = (readComponentType == GL_UNSIGNED_NORMALIZED ||
                                            readComponentType == GL_SIGNED_NORMALIZED);
-                    bool drawFixedPoint = (drawComponentType == GL_UNSIGNED_NORMALIZED ||
+                    bool drawFixedPoint      = (drawComponentType == GL_UNSIGNED_NORMALIZED ||
                                            drawComponentType == GL_SIGNED_NORMALIZED);
 
                     if (extensions.colorBufferFloat)
@@ -2753,7 +2753,7 @@ bool ValidateDrawBase(Context *context, GLenum mode, GLsizei count)
          uniformBlockIndex < program->getActiveUniformBlockCount(); uniformBlockIndex++)
     {
         const gl::InterfaceBlock &uniformBlock = program->getUniformBlockByIndex(uniformBlockIndex);
-        GLuint blockBinding                  = program->getUniformBlockBinding(uniformBlockIndex);
+        GLuint blockBinding                    = program->getUniformBlockBinding(uniformBlockIndex);
         const OffsetBindingPointer<Buffer> &uniformBuffer =
             state.getIndexedUniformBuffer(blockBinding);
 
@@ -5743,26 +5743,26 @@ bool ValidateTexParameterBase(Context *context,
         case GL_TEXTURE_WRAP_S:
         case GL_TEXTURE_WRAP_T:
         case GL_TEXTURE_WRAP_R:
+        {
+            bool restrictedWrapModes =
+                target == TextureType::External || target == TextureType::Rectangle;
+            if (!ValidateTextureWrapModeValue(context, params, restrictedWrapModes))
             {
-                bool restrictedWrapModes =
-                    target == TextureType::External || target == TextureType::Rectangle;
-                if (!ValidateTextureWrapModeValue(context, params, restrictedWrapModes))
-                {
-                    return false;
-                }
+                return false;
             }
-            break;
+        }
+        break;
 
         case GL_TEXTURE_MIN_FILTER:
+        {
+            bool restrictedMinFilter =
+                target == TextureType::External || target == TextureType::Rectangle;
+            if (!ValidateTextureMinFilterValue(context, params, restrictedMinFilter))
             {
-                bool restrictedMinFilter =
-                    target == TextureType::External || target == TextureType::Rectangle;
-                if (!ValidateTextureMinFilterValue(context, params, restrictedMinFilter))
-                {
-                    return false;
-                }
+                return false;
             }
-            break;
+        }
+        break;
 
         case GL_TEXTURE_MAG_FILTER:
             if (!ValidateTextureMagFilterValue(context, params))
@@ -5791,15 +5791,15 @@ bool ValidateTexParameterBase(Context *context,
             break;
 
         case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+        {
+            GLfloat paramValue = static_cast<GLfloat>(params[0]);
+            if (!ValidateTextureMaxAnisotropyValue(context, paramValue))
             {
-                GLfloat paramValue = static_cast<GLfloat>(params[0]);
-                if (!ValidateTextureMaxAnisotropyValue(context, paramValue))
-                {
-                    return false;
-                }
-                ASSERT(static_cast<ParamType>(paramValue) == params[0]);
+                return false;
             }
-            break;
+            ASSERT(static_cast<ParamType>(paramValue) == params[0]);
+        }
+        break;
 
         case GL_TEXTURE_MIN_LOD:
         case GL_TEXTURE_MAX_LOD:
@@ -6253,4 +6253,14 @@ bool ValidateFramebufferNotMultisampled(Context *context, Framebuffer *framebuff
     return true;
 }
 
+bool ValidateMultitextureUnit(Context *context, GLenum texture)
+{
+    if (texture < GL_TEXTURE0 || texture >= GL_TEXTURE0 + context->getCaps().maxMultitextureUnits)
+    {
+        ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidMultitextureUnit);
+        return false;
+    }
+    return true;
+}
+
 }  // namespace gl

src/libANGLE/validationES.h

@@ -617,6 +617,8 @@ bool ValidateGetInternalFormativBase(Context *context,
 bool ValidateFramebufferComplete(Context *context, Framebuffer *framebuffer, bool isFramebufferOp);
 bool ValidateFramebufferNotMultisampled(Context *context, Framebuffer *framebuffer);
 
+bool ValidateMultitextureUnit(Context *context, GLenum texture);
+
 // Utility macro for handling implementation methods inside Validation.
 #define ANGLE_HANDLE_VALIDATION_ERR(X) \
     context->handleError(X);           \

src/libANGLE/validationES1.cpp

@@ -11,6 +11,7 @@
 #include "common/debug.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/ErrorStrings.h"
+#include "libANGLE/validationES.h"
 
 #define ANGLE_VALIDATE_IS_GLES1(context)                              \
     if (context->getClientMajorVersion() > 1)                         \
@@ -73,14 +74,7 @@ bool ValidateClearDepthx(Context *context, GLfixed depth)
 bool ValidateClientActiveTexture(Context *context, GLenum texture)
 {
     ANGLE_VALIDATE_IS_GLES1(context);
-    if (texture < GL_TEXTURE0 ||
-        texture > GL_TEXTURE0 + context->getCaps().maxMultitextureUnits - 1)
-    {
-        ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidMultitextureUnit);
-        return false;
-    }
-
-    return true;
+    return ValidateMultitextureUnit(context, texture);
 }
 
 bool ValidateClipPlanef(Context *context, GLenum p, const GLfloat *eqn)
@@ -400,19 +394,19 @@ bool ValidateMultiTexCoord4f(Context *context,
                              GLfloat r,
                              GLfloat q)
 {
-    UNIMPLEMENTED();
-    return true;
+    ANGLE_VALIDATE_IS_GLES1(context);
+    return ValidateMultitextureUnit(context, target);
 }
 
 bool ValidateMultiTexCoord4x(Context *context,
-                             GLenum texture,
+                             GLenum target,
                              GLfixed s,
                              GLfixed t,
                              GLfixed r,
                              GLfixed q)
 {
-    UNIMPLEMENTED();
-    return true;
+    ANGLE_VALIDATE_IS_GLES1(context);
+    return ValidateMultitextureUnit(context, target);
 }
 
 bool ValidateNormal3f(Context *context, GLfloat nx, GLfloat ny, GLfloat nz)

src/libANGLE/validationES2.cpp

@@ -4347,6 +4347,11 @@ bool ValidateRequestExtensionANGLE(Context *context, const GLchar *name)
 
 bool ValidateActiveTexture(Context *context, GLenum texture)
 {
+    if (context->getClientMajorVersion() < 2)
+    {
+        return ValidateMultitextureUnit(context, texture);
+    }
+
     if (texture < GL_TEXTURE0 ||
         texture > GL_TEXTURE0 + context->getCaps().maxCombinedTextureImageUnits - 1)
     {

src/tests/angle_end2end_tests.gypi

@@ -51,6 +51,7 @@
             '<(angle_path)/src/tests/gl_tests/gles1/ClientActiveTextureTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/CurrentColorTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/CurrentNormalTest.cpp',
+            '<(angle_path)/src/tests/gl_tests/gles1/CurrentTextureCoordsTest.cpp',
             '<(angle_path)/src/tests/gl_tests/GLSLTest.cpp',
             '<(angle_path)/src/tests/gl_tests/ImageTest.cpp',
             '<(angle_path)/src/tests/gl_tests/IncompleteTextureTest.cpp',

src/tests/gl_tests/gles1/CurrentTextureCoordsTest.cpp

+//
+// Copyright 2018 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.
+//
+
+// CurrentTextureCoordsTest.cpp: Tests basic usage of glMultiTexCoord4(f|x).
+
+#include "test_utils/ANGLETest.h"
+#include "test_utils/gl_raii.h"
+
+#include "random_utils.h"
+
+#include "common/vector_utils.h"
+
+#include <array>
+
+#include <stdint.h>
+
+using namespace angle;
+
+using TextureCoord = std::array<float, 4>;
+
+class CurrentTextureCoordsTest : public ANGLETest
+{
+  protected:
+    CurrentTextureCoordsTest()
+    {
+        setWindowWidth(32);
+        setWindowHeight(32);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(24);
+    }
+};
+
+// State query: Checks the initial state is correct.
+TEST_P(CurrentTextureCoordsTest, InitialState)
+{
+    GLint maxUnits = 0;
+    glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxUnits);
+    EXPECT_GL_NO_ERROR();
+
+    const TextureCoord kZero = {0.0f, 0.0f, 0.0f, 0.0f};
+    TextureCoord actualTexCoord;
+
+    for (GLint i = 0; i < maxUnits; i++)
+    {
+        glActiveTexture(GL_TEXTURE0 + i);
+        EXPECT_GL_NO_ERROR();
+        glGetFloatv(GL_CURRENT_TEXTURE_COORDS, actualTexCoord.data());
+        EXPECT_GL_NO_ERROR();
+        EXPECT_EQ(kZero, actualTexCoord);
+    }
+}
+
+// Checks that errors are generated if the texture unit specified is invalid.
+TEST_P(CurrentTextureCoordsTest, Negative)
+{
+    GLint maxUnits = 0;
+    glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxUnits);
+    EXPECT_GL_NO_ERROR();
+
+    glMultiTexCoord4f(GL_TEXTURE0 - 1, 1.0f, 0.0f, 0.0f, 0.0f);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+
+    glMultiTexCoord4f(GL_TEXTURE0 + maxUnits, 1.0f, 0.0f, 0.0f, 0.0f);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+}
+
+// Tests setting and getting the current texture coordinates for each unit and with float/fixed
+// inputs.
+TEST_P(CurrentTextureCoordsTest, Set)
+{
+    float epsilon  = 0.00001f;
+    GLint maxUnits = 0;
+    glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxUnits);
+    EXPECT_GL_NO_ERROR();
+
+    TextureCoord actualTexCoord;
+
+    for (int i = 0; i < maxUnits; i++)
+    {
+        glActiveTexture(GL_TEXTURE0 + i);
+        glMultiTexCoord4f(GL_TEXTURE0 + i, 0.1f, 0.2f, 0.3f, 0.4f);
+        glGetFloatv(GL_CURRENT_TEXTURE_COORDS, actualTexCoord.data());
+        EXPECT_EQ((TextureCoord{0.1f, 0.2f, 0.3f, 0.4f}), actualTexCoord);
+
+        glMultiTexCoord4x(GL_TEXTURE0 + i, 0x10000, 0x0, 0x3333, 0x5555);
+        glGetFloatv(GL_CURRENT_TEXTURE_COORDS, actualTexCoord.data());
+        EXPECT_NEAR(1.0f, actualTexCoord[0], epsilon);
+        EXPECT_NEAR(0.0f, actualTexCoord[1], epsilon);
+        EXPECT_NEAR(0.2f, actualTexCoord[2], epsilon);
+        EXPECT_NEAR(1.0f / 3.0f, actualTexCoord[3], epsilon);
+    }
+}
+
+ANGLE_INSTANTIATE_TEST(CurrentTextureCoordsTest, ES1_D3D11(), ES1_OPENGL(), ES1_OPENGLES());