Capture/Replay: Fill out more ES 3.0 state in mid-execution capture

src/libANGLE/FrameCapture.cpp

@@ -1429,12 +1429,12 @@ void CaptureMidExecutionSetup(const gl::Context *context,
         }
     }
 
-    // Set a pack alignment of 1.
-    gl::PixelPackState &currentPackState = replayState.getPackState();
-    if (currentPackState.alignment != 1)
+    // Set a unpack alignment of 1.
+    gl::PixelUnpackState &currentUnpackState = replayState.getUnpackState();
+    if (currentUnpackState.alignment != 1)
     {
         cap(CapturePixelStorei(replayState, true, GL_UNPACK_ALIGNMENT, 1));
-        currentPackState.alignment = 1;
+        currentUnpackState.alignment = 1;
     }
 
     // Capture Texture setup and data.
@@ -1470,6 +1470,10 @@ void CaptureMidExecutionSetup(const gl::Context *context,
             cap(CaptureTexParameteri(replayState, true, texture->getType(), pname, param));
         };
 
+        auto capTexParamf = [cap, &replayState, texture](GLenum pname, GLfloat param) {
+            cap(CaptureTexParameterf(replayState, true, texture->getType(), pname, param));
+        };
+
         if (textureSamplerState.getMinFilter() != defaultSamplerState.getMinFilter())
         {
             capTexParam(GL_TEXTURE_MIN_FILTER, textureSamplerState.getMinFilter());
@@ -1495,6 +1499,48 @@ void CaptureMidExecutionSetup(const gl::Context *context,
             capTexParam(GL_TEXTURE_WRAP_T, textureSamplerState.getWrapT());
         }
 
+        if (textureSamplerState.getMinLod() != defaultSamplerState.getMinLod())
+        {
+            capTexParamf(GL_TEXTURE_MIN_LOD, textureSamplerState.getMinLod());
+        }
+
+        if (textureSamplerState.getMaxLod() != defaultSamplerState.getMaxLod())
+        {
+            capTexParamf(GL_TEXTURE_MAX_LOD, textureSamplerState.getMaxLod());
+        }
+
+        if (textureSamplerState.getCompareMode() != defaultSamplerState.getCompareMode())
+        {
+            capTexParam(GL_TEXTURE_COMPARE_MODE, textureSamplerState.getCompareMode());
+        }
+
+        if (textureSamplerState.getCompareFunc() != defaultSamplerState.getCompareFunc())
+        {
+            capTexParam(GL_TEXTURE_COMPARE_FUNC, textureSamplerState.getCompareFunc());
+        }
+
+        // Texture parameters
+        // TODO: Add immutable and base/max when TexStorage is handled (http://anglebug.com/3662)
+        if (texture->getSwizzleRed() != GL_RED)
+        {
+            capTexParam(GL_TEXTURE_SWIZZLE_R, texture->getSwizzleRed());
+        }
+
+        if (texture->getSwizzleGreen() != GL_GREEN)
+        {
+            capTexParam(GL_TEXTURE_SWIZZLE_G, texture->getSwizzleGreen());
+        }
+
+        if (texture->getSwizzleBlue() != GL_BLUE)
+        {
+            capTexParam(GL_TEXTURE_SWIZZLE_B, texture->getSwizzleBlue());
+        }
+
+        if (texture->getSwizzleAlpha() != GL_ALPHA)
+        {
+            capTexParam(GL_TEXTURE_SWIZZLE_A, texture->getSwizzleAlpha());
+        }
+
         // Iterate texture levels and layers.
         gl::ImageIndexIterator imageIter = gl::ImageIndexIterator::MakeGeneric(
             texture->getType(), 0, texture->getMipmapMaxLevel() + 1, gl::ImageIndex::kEntireLevel,
@@ -2167,14 +2213,69 @@ void CaptureMidExecutionSetup(const gl::Context *context,
     }
 
     // Pixel storage states.
-    // TODO(jmadill): ES 3.x+ implementation. http://anglebug.com/3662
+    gl::PixelPackState &currentPackState = replayState.getPackState();
     if (currentPackState.alignment != apiState.getPackAlignment())
     {
-        cap(CapturePixelStorei(replayState, true, GL_UNPACK_ALIGNMENT,
-                               apiState.getPackAlignment()));
+        cap(CapturePixelStorei(replayState, true, GL_PACK_ALIGNMENT, apiState.getPackAlignment()));
         currentPackState.alignment = apiState.getPackAlignment();
     }
 
+    if (currentPackState.rowLength != apiState.getPackRowLength())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_PACK_ROW_LENGTH, apiState.getPackRowLength()));
+        currentPackState.rowLength = apiState.getPackRowLength();
+    }
+
+    if (currentPackState.skipRows != apiState.getPackSkipRows())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_PACK_SKIP_ROWS, apiState.getPackSkipRows()));
+        currentPackState.skipRows = apiState.getPackSkipRows();
+    }
+
+    if (currentPackState.skipPixels != apiState.getPackSkipPixels())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_PACK_SKIP_PIXELS,
+                               apiState.getPackSkipPixels()));
+        currentPackState.skipPixels = apiState.getPackSkipPixels();
+    }
+
+    // We set unpack alignment above, no need to change it here
+    ASSERT(currentUnpackState.alignment == 1);
+    if (currentUnpackState.rowLength != apiState.getUnpackRowLength())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_UNPACK_ROW_LENGTH,
+                               apiState.getUnpackRowLength()));
+        currentUnpackState.rowLength = apiState.getUnpackRowLength();
+    }
+
+    if (currentUnpackState.skipRows != apiState.getUnpackSkipRows())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_UNPACK_SKIP_ROWS,
+                               apiState.getUnpackSkipRows()));
+        currentUnpackState.skipRows = apiState.getUnpackSkipRows();
+    }
+
+    if (currentUnpackState.skipPixels != apiState.getUnpackSkipPixels())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_UNPACK_SKIP_PIXELS,
+                               apiState.getUnpackSkipPixels()));
+        currentUnpackState.skipPixels = apiState.getUnpackSkipPixels();
+    }
+
+    if (currentUnpackState.imageHeight != apiState.getUnpackImageHeight())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_UNPACK_IMAGE_HEIGHT,
+                               apiState.getUnpackImageHeight()));
+        currentUnpackState.imageHeight = apiState.getUnpackImageHeight();
+    }
+
+    if (currentUnpackState.skipImages != apiState.getUnpackSkipImages())
+    {
+        cap(CapturePixelStorei(replayState, true, GL_UNPACK_SKIP_IMAGES,
+                               apiState.getUnpackSkipImages()));
+        currentUnpackState.skipImages = apiState.getUnpackSkipImages();
+    }
+
     // Clear state. Missing ES 3.x features.
     // TODO(http://anglebug.com/3662): Complete state capture.
     const gl::ColorF &currentClearColor = apiState.getColorClearValue();
@@ -2189,6 +2290,11 @@ void CaptureMidExecutionSetup(const gl::Context *context,
         cap(CaptureClearDepthf(replayState, true, apiState.getDepthClearValue()));
     }
 
+    if (apiState.getStencilClearValue() != 0)
+    {
+        cap(CaptureClearStencil(replayState, true, apiState.getStencilClearValue()));
+    }
+
     // Viewport / scissor / clipping planes.
     const gl::Rectangle &currentViewport = apiState.getViewport();
     if (currentViewport != gl::Rectangle())
@@ -2214,6 +2320,14 @@ void CaptureMidExecutionSetup(const gl::Context *context,
                            currentScissor.width, currentScissor.height));
     }
 
+    const gl::SyncManager &syncs = apiState.getSyncManagerForCapture();
+    for (const auto &syncIter : syncs)
+    {
+        // TODO: Create existing sync objects (http://anglebug.com/3662)
+        (void)syncIter;
+        UNIMPLEMENTED();
+    }
+
     // Allow the replayState object to be destroyed conveniently.
     replayState.setBufferBinding(context, gl::BufferBinding::Array, nullptr);
 }

src/libANGLE/State.h

@@ -734,6 +734,7 @@ class State : angle::NonCopyable
     {
         return *mShaderProgramManager;
     }
+    const SyncManager &getSyncManagerForCapture() const { return *mSyncManager; }
     const SamplerManager &getSamplerManagerForCapture() const { return *mSamplerManager; }
     const SamplerBindingVector &getSamplerBindingsForCapture() const { return mSamplers; }