WebGL, D3D: Forbid multiple TF outputs in one buffer

src/libANGLE/Buffer.cpp

@@ -268,6 +268,11 @@ bool Buffer::isBoundForTransformFeedbackAndOtherUse() const
                mState.mBindingCount - mState.mTransformFeedbackGenericBindingCount;
 }
 
+bool Buffer::isDoubleBoundForTransformFeedback() const
+{
+    return mState.mTransformFeedbackIndexedBindingCount > 1;
+}
+
 void Buffer::onTFBindingChanged(const Context *context, bool bound, bool indexed)
 {
     ASSERT(bound || mState.mBindingCount > 0);

src/libANGLE/Buffer.h

@@ -123,6 +123,7 @@ class Buffer final : public RefCountObject,
 
     bool isBound() const;
     bool isBoundForTransformFeedbackAndOtherUse() const;
+    bool isDoubleBoundForTransformFeedback() const;
     void onTFBindingChanged(const Context *context, bool bound, bool indexed);
     void onNonTFBindingChanged(int incr) { mState.mBindingCount += incr; }
 

src/libANGLE/Caps.cpp

@@ -286,7 +286,8 @@ Limitations::Limitations()
       noSeparateStencilRefsAndMasks(false),
       shadersRequireIndexedLoopValidation(false),
       noSimultaneousConstantColorAndAlphaBlendFunc(false),
-      noFlexibleVaryingPacking(false)
+      noFlexibleVaryingPacking(false),
+      noDoubleBoundTransformFeedbackBuffers(false)
 {
 }
 

src/libANGLE/Caps.h

@@ -506,6 +506,9 @@ struct Limitations
 
     // D3D9 does not support flexible varying register packing.
     bool noFlexibleVaryingPacking;
+
+    // D3D does not support having multiple transform feedback outputs go to the same buffer.
+    bool noDoubleBoundTransformFeedbackBuffers;
 };
 
 struct TypePrecision

src/libANGLE/ErrorStrings.h

@@ -104,6 +104,8 @@ constexpr const char *kErrorDestinationTextureTooSmall = "Destination texture to
 constexpr const char *kErrorDimensionsMustBePow2       = "Texture dimensions must be power-of-two.";
 constexpr const char *kErrorDispatchIndirectBufferNotBound =
     "Dispatch indirect buffer must be bound.";
+constexpr const char *kErrorDoubleBoundTransformFeedbackBuffer =
+    "Transform feedback has a buffer bound to multiple outputs.";
 constexpr const char *kErrorDrawIndirectBufferNotBound = "Draw indirect buffer must be bound.";
 constexpr const char *kErrorDrawBufferTypeMismatch =
     "Fragment shader output type does not match the bound framebuffer attachment type.";

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

@@ -1654,6 +1654,9 @@ void GenerateCaps(ID3D11Device *device,
     // D3D11 cannot support constant color and alpha blend funcs together
     limitations->noSimultaneousConstantColorAndAlphaBlendFunc = true;
 
+    // D3D11 does not support multiple transform feedback outputs writing to the same buffer.
+    limitations->noDoubleBoundTransformFeedbackBuffers = true;
+
 #ifdef ANGLE_ENABLE_WINDOWS_STORE
     // Setting a non-zero divisor on attribute zero doesn't work on certain Windows Phone 8-era
     // devices. We should prevent developers from doing this on ALL Windows Store devices. This will

src/libANGLE/validationES3.cpp

@@ -2472,11 +2472,22 @@ bool ValidateBeginTransformFeedback(Context *context, PrimitiveMode primitiveMod
     for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++)
     {
         const auto &buffer = transformFeedback->getIndexedBuffer(i);
-        if (buffer.get() && buffer->isMapped())
+        if (buffer.get())
         {
-            context->validationError(GL_INVALID_OPERATION,
-                                     "Transform feedback has a mapped buffer.");
-            return false;
+            if (buffer->isMapped())
+            {
+                context->validationError(GL_INVALID_OPERATION,
+                                         "Transform feedback has a mapped buffer.");
+                return false;
+            }
+            if ((context->getLimitations().noDoubleBoundTransformFeedbackBuffers ||
+                 context->getExtensions().webglCompatibility) &&
+                buffer->isDoubleBoundForTransformFeedback())
+            {
+                context->validationError(GL_INVALID_OPERATION,
+                                         kErrorDoubleBoundTransformFeedbackBuffer);
+                return false;
+            }
         }
     }
 

src/tests/gl_tests/WebGLCompatibilityTest.cpp

@@ -4254,6 +4254,30 @@ TEST_P(WebGL2CompatibilityTest, TransformFeedbackCheckNullDeref)
     EXPECT_GL_ERROR(GL_INVALID_OPERATION);
 }
 
+// We should forbid two transform feedback outputs going to the same buffer.
+TEST_P(WebGL2CompatibilityTest, TransformFeedbackDoubleBinding)
+{
+    constexpr char kVS[] =
+        R"(attribute float a; varying float b; varying float c; void main() { b = a; c = a; })";
+    constexpr char kFS[] = R"(void main(){})";
+    ANGLE_GL_PROGRAM(program, kVS, kFS);
+    static const char *varyings[] = {"b", "c"};
+    glTransformFeedbackVaryings(program, 2, varyings, GL_SEPARATE_ATTRIBS);
+    glLinkProgram(program);
+    glUseProgram(program);
+    ASSERT_GL_NO_ERROR();
+
+    // Bind the transform feedback varyings to non-overlapping regions of the same buffer.
+    GLBuffer buffer;
+    glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buffer, 0, 4);
+    glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 1, buffer, 4, 4);
+    glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 8, nullptr, GL_STATIC_DRAW);
+    ASSERT_GL_NO_ERROR();
+    // Two varyings bound to the same buffer should be an error.
+    glBeginTransformFeedback(GL_POINTS);
+    EXPECT_GL_ERROR(GL_INVALID_OPERATION);
+}
+
 // Check the return type of a given parameter upon getting the active uniforms.
 TEST_P(WebGL2CompatibilityTest, UniformVariablesReturnTypes)
 {