FramebufferNULL::readPixels: write pixels for tests

src/libANGLE/renderer/null/BufferNULL.cpp

@@ -107,4 +107,14 @@ gl::Error BufferNULL::getIndexRange(GLenum type,
     return gl::NoError();
 }
 
+uint8_t *BufferNULL::getDataPtr()
+{
+    return mData.data();
+}
+
+const uint8_t *BufferNULL::getDataPtr() const
+{
+    return mData.data();
+}
+
 }  // namespace rx

src/libANGLE/renderer/null/BufferNULL.h

@@ -52,6 +52,9 @@ class BufferNULL : public BufferImpl
                             bool primitiveRestartEnabled,
                             gl::IndexRange *outRange) override;
 
+    uint8_t *getDataPtr();
+    const uint8_t *getDataPtr() const;
+
   private:
     std::vector<uint8_t> mData;
 

src/libANGLE/renderer/null/FramebufferNULL.cpp

@@ -9,7 +9,9 @@
 
 #include "libANGLE/renderer/null/FramebufferNULL.h"
 
+#include "libANGLE/Context.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/null/BufferNULL.h"
 
 #include "common/debug.h"
 
@@ -111,11 +113,60 @@ GLenum FramebufferNULL::getImplementationColorReadType(const gl::Context *contex
 }
 
 gl::Error FramebufferNULL::readPixels(const gl::Context *context,
-                                      const gl::Rectangle &area,
+                                      const gl::Rectangle &origArea,
                                       GLenum format,
                                       GLenum type,
-                                      void *pixels) const
+                                      void *ptrOrOffset) const
 {
+    const gl::PixelPackState &packState = context->getGLState().getPackState();
+
+    // Get the pointer to write to from the argument or the pack buffer
+    GLubyte *pixels = nullptr;
+    if (packState.pixelBuffer.get() != nullptr)
+    {
+        BufferNULL *pixelBuffer = GetImplAs<BufferNULL>(packState.pixelBuffer.get());
+        pixels                  = reinterpret_cast<GLubyte *>(pixelBuffer->getDataPtr());
+        pixels += reinterpret_cast<intptr_t>(ptrOrOffset);
+    }
+    else
+    {
+        pixels = reinterpret_cast<GLubyte *>(ptrOrOffset);
+    }
+
+    // Clip read area to framebuffer.
+    const gl::Extents fbSize = getState().getReadAttachment()->getSize();
+    const gl::Rectangle fbRect(0, 0, fbSize.width, fbSize.height);
+    gl::Rectangle area;
+    if (!ClipRectangle(origArea, fbRect, &area))
+    {
+        // nothing to read
+        return gl::NoError();
+    }
+
+    // Compute size of unclipped rows and initial skip
+    const gl::InternalFormat &glFormat = gl::GetInternalFormatInfo(format, type);
+
+    GLuint rowBytes = 0;
+    ANGLE_TRY_RESULT(
+        glFormat.computeRowPitch(type, origArea.width, packState.alignment, packState.rowLength),
+        rowBytes);
+
+    GLuint skipBytes = 0;
+    ANGLE_TRY_RESULT(glFormat.computeSkipBytes(rowBytes, 0, packState, false), skipBytes);
+    pixels += skipBytes;
+
+    // Skip OOB region up to first in bounds pixel
+    int leftClip = area.x - origArea.x;
+    int topClip  = area.y - origArea.y;
+    pixels += leftClip * glFormat.pixelBytes + topClip * rowBytes;
+
+    // Write the in-bounds readpixels data with non-zero values
+    for (GLint y = area.y; y < area.y + area.height; ++y)
+    {
+        memset(pixels, 42, glFormat.pixelBytes * area.width);
+        pixels += rowBytes;
+    }
+
     return gl::NoError();
 }