[Fix] (MG_State, MG_Impl): GL-order capture for geometry triangle strips

Vulkan transform feedback captures odd strip triangles as (i, i+2, i+1)
while GL table 10.1 decomposes them as (i+1, i, i+2). When the capture
stage is a triangle-strip geometry shader whose EmitVertex/EndPrimitive
sequence is statically knowable (no emission under control flow), link
time extracts the per-invocation strip lengths from the glslang AST, and
EndTransformFeedback rotates each odd triangle's captured vertex records
into GL order in place (bounded by the binding ranges' whole-triangle
capacity; raw input primitives tracked per Begin/End).
KHR-GL33.transform_feedback.geometry passes - the family is 21/21.

MobileGL/MG_State/GLState/Core.h

@@ -218,6 +218,7 @@ namespace MobileGL {
                     m_transformFeedbackProgram = program;
                     ++m_transformFeedbackGeneration;
                     m_transformFeedbackCapturedVertices = 0;
+                    m_transformFeedbackInputPrimitives = 0;
                 }
                 void EndTransformFeedback() {
                     m_transformFeedbackActive = false;
@@ -244,6 +245,12 @@ namespace MobileGL {
                     m_transformFeedbackCapturedVertices += vertices;
                 }
                 Uint64 GetTransformFeedbackCapturedVertices() const { return m_transformFeedbackCapturedVertices; }
+                // Raw assembled input primitives fed to the capture stage since Begin
+                // (pre-clamp; drives the GS strip capture-order fixup at EndTF).
+                void AddTransformFeedbackInputPrimitives(Uint64 primitives) {
+                    m_transformFeedbackInputPrimitives += primitives;
+                }
+                Uint64 GetTransformFeedbackInputPrimitives() const { return m_transformFeedbackInputPrimitives; }
 
                 // Framebuffer
                 void GenFramebufferNames(Uint number, Vector<Uint>& framebuffers);
@@ -283,6 +290,7 @@ namespace MobileGL {
                 Uint64 m_transformFeedbackGeneration = 0;
                 Uint64 m_transformFeedbackPrimitiveCounter = 0;
                 Uint64 m_transformFeedbackCapturedVertices = 0;
+                Uint64 m_transformFeedbackInputPrimitives = 0;
                 TextureState m_textureState;
                 ProgramState m_programState;
                 RenderState m_renderState;

MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp

@@ -324,9 +324,76 @@ namespace MobileGL::MG_State::GLState {
                 m_xfbStrides[i] = m_xfbVaryings[i].byteSize;
             }
         }
+
+        ResolveGsTriangleStripCapture(captureIntermediate);
         return true;
     }
 
+    namespace {
+        // Extracts a geometry shader's per-invocation EmitVertex/EndPrimitive sequence
+        // when it is statically knowable (no emit inside selection/loop/switch). Vulkan
+        // transform feedback captures triangle strips in plain (i, i+1, i+2) order while
+        // GL decomposes odd strip triangles as (i+1, i, i+2) (GL 4.6 table 10.1); with
+        // the static strip lengths the capture buffer can be reordered after EndTF.
+        class GsEmitSequenceTraverser final : public glslang::TIntermTraverser {
+        public:
+            bool visitAggregate(glslang::TVisit, glslang::TIntermAggregate* node) override {
+                if (node->getOp() == glslang::EOpEmitVertex) {
+                    ++emitCount;
+                    hasEmit = true;
+                } else if (node->getOp() == glslang::EOpEndPrimitive) {
+                    FlushStrip();
+                }
+                return true;
+            }
+            bool visitSelection(glslang::TVisit, glslang::TIntermSelection*) override {
+                inControlFlow = true;
+                return true;
+            }
+            bool visitLoop(glslang::TVisit, glslang::TIntermLoop*) override {
+                inControlFlow = true;
+                return true;
+            }
+            bool visitSwitch(glslang::TVisit, glslang::TIntermSwitch*) override {
+                inControlFlow = true;
+                return true;
+            }
+            void FlushStrip() {
+                if (emitCount >= 3) {
+                    stripTriangles.push_back(static_cast<Uint32>(emitCount - 2));
+                }
+                emitCount = 0;
+            }
+
+            Vector<Uint32> stripTriangles;
+            Uint32 emitCount = 0;
+            Bool hasEmit = false;
+            Bool inControlFlow = false;
+        };
+    } // namespace
+
+    void ProgramObject::ResolveGsTriangleStripCapture(const glslang::TIntermediate* captureIntermediate) {
+        m_gsStripTriangles.clear();
+        m_gsStripCaptureFixup = false;
+        if (captureIntermediate == nullptr || m_program == nullptr) {
+            return;
+        }
+        if (m_program->getIntermediate(EShLangGeometry) != captureIntermediate) {
+            return;
+        }
+        if (captureIntermediate->getOutputPrimitive() != glslang::ElgTriangleStrip) {
+            return;
+        }
+        GsEmitSequenceTraverser traverser;
+        const_cast<glslang::TIntermediate*>(captureIntermediate)->getTreeRoot()->traverse(&traverser);
+        traverser.FlushStrip(); // the invocation end acts as an implicit EndPrimitive
+        if (!traverser.hasEmit || traverser.inControlFlow || traverser.stripTriangles.empty()) {
+            return;
+        }
+        m_gsStripTriangles = Move(traverser.stripTriangles);
+        m_gsStripCaptureFixup = true;
+    }
+
     bool ProgramObject::ShaderIsAttached(const SharedPtr<ShaderObject>& shader) {
         MGLOG_D("ProgramObject %u: ShaderIsAttached check for shader %p", m_externalIndex, shader.get());
         auto it = std::find_if(m_shaders.begin(), m_shaders.end(),

MobileGL/MG_State/GLState/ProgramState/ProgramObject.h

@@ -491,6 +491,12 @@ namespace MobileGL::MG_State::GLState {
         }
         SizeT GetTransformFeedbackBufferCount() const { return m_xfbStrides.size(); }
         Int GetTransformFeedbackVaryingMaxLength() const { return m_xfbVaryingNameMaxLength; }
+        // True when the capture stage is a triangle-strip geometry shader with a
+        // statically-known emit sequence: the Vulkan capture order then needs the GL
+        // odd-triangle vertex swap after EndTransformFeedback.
+        Bool HasGsTriangleStripCaptureFixup() const { return m_gsStripCaptureFixup; }
+        // Triangles per strip, in emission order, for ONE geometry invocation.
+        const Vector<Uint32>& GetGsStripTriangles() const { return m_gsStripTriangles; }
 
         Uint GetExternalIndex() const { return m_externalIndex; }
         // Globally-unique, never-reused id for this program object's lifetime. Unlike the GL
@@ -506,6 +512,7 @@ namespace MobileGL::MG_State::GLState {
         // vertex stage; fails the link (GL semantics) on unknown or duplicate
         // names or exceeded capture limits.
         Bool ResolveTransformFeedbackVaryings();
+        void ResolveGsTriangleStripCapture(const glslang::TIntermediate* captureIntermediate);
         void GenerateBinary();
         void WaitUntilGenerationCompleted() const;
         void AddDefaultFragmentShaderIfMissing();
@@ -595,6 +602,8 @@ namespace MobileGL::MG_State::GLState {
         GLenum m_requestedXfbBufferMode = GL_INTERLEAVED_ATTRIBS;
         Vector<XfbVarying> m_xfbVaryings;
         Vector<Uint32> m_xfbStrides;
+        Vector<Uint32> m_gsStripTriangles;
+        Bool m_gsStripCaptureFixup = false;
         GLenum m_xfbBufferMode = GL_INTERLEAVED_ATTRIBS;
         Int m_xfbVaryingNameMaxLength = 0;
     };