LibGL: Implement glReadPixels()

3 files changed, 249 insertions, 0 deletions

diff --git a/Userland/Libraries/LibGL/SoftwareGLContext.cpp b/Userland/Libraries/LibGL/SoftwareGLContext.cpp
index d985ddd2d0..950c948f89 100644
--- a/Userland/Libraries/LibGL/SoftwareGLContext.cpp
+++ b/Userland/Libraries/LibGL/SoftwareGLContext.cpp
@@ -1113,10 +1113,239 @@ void SoftwareGLContext::gl_read_pixels(GLint x, GLint y, GLsizei width, GLsizei
         }
     }
 
+    // Some helper functions for converting float values to integer types
+    auto float_to_i8 = [](float f) -> GLchar {
+        return static_cast<GLchar>((0x7f * min(max(f, 0.0f), 1.0f) - 1) / 2);
+    };
+
+    auto float_to_i16 = [](float f) -> GLshort {
+        return static_cast<GLshort>((0x7fff * min(max(f, 0.0f), 1.0f) - 1) / 2);
+    };
+
+    auto float_to_i32 = [](float f) -> GLint {
+        return static_cast<GLint>((0x7fffffff * min(max(f, 0.0f), 1.0f) - 1) / 2);
+    };
+
+    auto float_to_u8 = [](float f) -> GLubyte {
+        return static_cast<GLubyte>(0xff * min(max(f, 0.0f), 1.0f));
+    };
+
+    auto float_to_u16 = [](float f) -> GLushort {
+        return static_cast<GLushort>(0xffff * min(max(f, 0.0f), 1.0f));
+    };
+
+    auto float_to_u32 = [](float f) -> GLuint {
+        return static_cast<GLuint>(0xffffffff * min(max(f, 0.0f), 1.0f));
+    };
+
     if (format == GL_DEPTH_COMPONENT) {
         // Read from depth buffer
+        for (size_t i = 0; i < height; ++i) {
+            for (size_t j = 0; j < width; ++j) {
+                float depth = m_rasterizer.get_depthbuffer_value(x + j, y + i);
+
+                switch (type) {
+                case GL_BYTE:
+                    reinterpret_cast<GLchar*>(pixels)[i * width + j] = float_to_i8(depth);
+                    break;
+                case GL_SHORT:
+                    reinterpret_cast<GLshort*>(pixels)[i * width + j] = float_to_i16(depth);
+                    break;
+                case GL_INT:
+                    reinterpret_cast<GLint*>(pixels)[i * width + j] = float_to_i32(depth);
+                    break;
+                case GL_UNSIGNED_BYTE:
+                    reinterpret_cast<GLubyte*>(pixels)[i * width + j] = float_to_u8(depth);
+                    break;
+                case GL_UNSIGNED_SHORT:
+                    reinterpret_cast<GLushort*>(pixels)[i * width + j] = float_to_u16(depth);
+                    break;
+                case GL_UNSIGNED_INT:
+                    reinterpret_cast<GLuint*>(pixels)[i * width + j] = float_to_u32(depth);
+                    break;
+                case GL_FLOAT:
+                    reinterpret_cast<GLfloat*>(pixels)[i * width + j] = min(max(depth, 0.0f), 1.0f);
+                    break;
+                }
+            }
+        }
         return;
     }
+
+    bool write_red = false;
+    bool write_green = false;
+    bool write_blue = false;
+    bool write_alpha = false;
+    size_t component_count = 0;
+    size_t component_size = 0;
+    size_t red_offset = 0;
+    size_t green_offset = 0;
+    size_t blue_offset = 0;
+    size_t alpha_offset = 0;
+    char* red_ptr = nullptr;
+    char* green_ptr = nullptr;
+    char* blue_ptr = nullptr;
+    char* alpha_ptr = nullptr;
+
+    switch (format) {
+    case GL_RGB:
+        write_red = true;
+        write_green = true;
+        write_blue = true;
+        component_count = 3;
+        red_offset = 2;
+        green_offset = 1;
+        blue_offset = 0;
+        break;
+    case GL_RGBA:
+        write_red = true;
+        write_green = true;
+        write_blue = true;
+        write_alpha = true;
+        component_count = 4;
+        red_offset = 3;
+        green_offset = 2;
+        blue_offset = 1;
+        alpha_offset = 0;
+        break;
+    case GL_RED:
+        write_red = true;
+        component_count = 1;
+        red_offset = 0;
+        break;
+    case GL_GREEN:
+        write_green = true;
+        component_count = 1;
+        green_offset = 0;
+        break;
+    case GL_BLUE:
+        write_blue = true;
+        component_count = 1;
+        blue_offset = 0;
+        break;
+    case GL_ALPHA:
+        write_alpha = true;
+        component_count = 1;
+        alpha_offset = 0;
+        break;
+    }
+
+    switch (type) {
+    case GL_BYTE:
+    case GL_UNSIGNED_BYTE:
+        component_size = 1;
+        break;
+    case GL_SHORT:
+    case GL_UNSIGNED_SHORT:
+        component_size = 2;
+        break;
+    case GL_INT:
+    case GL_UNSIGNED_INT:
+    case GL_FLOAT:
+        component_size = 4;
+        break;
+    }
+
+    char* out_ptr = reinterpret_cast<char*>(pixels);
+    for (int i = 0; i < (int)height; ++i) {
+        for (int j = 0; j < (int)width; ++j) {
+            Gfx::RGBA32 color {};
+            if (m_current_read_buffer == GL_FRONT || m_current_read_buffer == GL_LEFT || m_current_read_buffer == GL_FRONT_LEFT) {
+                if (y + i >= m_frontbuffer->width() || x + j >= m_frontbuffer->height())
+                    color = 0;
+                else
+                    color = m_frontbuffer->scanline(y + i)[x + j];
+            } else {
+                color = m_rasterizer.get_backbuffer_pixel(x + j, y + i);
+            }
+
+            float red = ((color >> 24) & 0xff) / 255.0f;
+            float green = ((color >> 16) & 0xff) / 255.0f;
+            float blue = ((color >> 8) & 0xff) / 255.0f;
+            float alpha = (color & 0xff) / 255.0f;
+
+            // FIXME: Set up write pointers based on selected endianness (glPixelStore)
+            red_ptr = out_ptr + (component_size * red_offset);
+            green_ptr = out_ptr + (component_size * green_offset);
+            blue_ptr = out_ptr + (component_size * blue_offset);
+            alpha_ptr = out_ptr + (component_size * alpha_offset);
+
+            switch (type) {
+            case GL_BYTE:
+                if (write_red)
+                    *reinterpret_cast<GLchar*>(red_ptr) = float_to_i8(red);
+                if (write_green)
+                    *reinterpret_cast<GLchar*>(green_ptr) = float_to_i8(green);
+                if (write_blue)
+                    *reinterpret_cast<GLchar*>(blue_ptr) = float_to_i8(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLchar*>(alpha_ptr) = float_to_i8(alpha);
+                break;
+            case GL_UNSIGNED_BYTE:
+                if (write_red)
+                    *reinterpret_cast<GLubyte*>(red_ptr) = float_to_u8(red);
+                if (write_green)
+                    *reinterpret_cast<GLubyte*>(green_ptr) = float_to_u8(green);
+                if (write_blue)
+                    *reinterpret_cast<GLubyte*>(blue_ptr) = float_to_u8(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLubyte*>(alpha_ptr) = float_to_u8(alpha);
+                break;
+            case GL_SHORT:
+                if (write_red)
+                    *reinterpret_cast<GLshort*>(red_ptr) = float_to_i16(red);
+                if (write_green)
+                    *reinterpret_cast<GLshort*>(green_ptr) = float_to_i16(green);
+                if (write_blue)
+                    *reinterpret_cast<GLshort*>(blue_ptr) = float_to_i16(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLshort*>(alpha_ptr) = float_to_i16(alpha);
+                break;
+            case GL_UNSIGNED_SHORT:
+                if (write_red)
+                    *reinterpret_cast<GLushort*>(red_ptr) = float_to_u16(red);
+                if (write_green)
+                    *reinterpret_cast<GLushort*>(green_ptr) = float_to_u16(green);
+                if (write_blue)
+                    *reinterpret_cast<GLushort*>(blue_ptr) = float_to_u16(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLushort*>(alpha_ptr) = float_to_u16(alpha);
+                break;
+            case GL_INT:
+                if (write_red)
+                    *reinterpret_cast<GLint*>(red_ptr) = float_to_i32(red);
+                if (write_green)
+                    *reinterpret_cast<GLint*>(green_ptr) = float_to_i32(green);
+                if (write_blue)
+                    *reinterpret_cast<GLint*>(blue_ptr) = float_to_i32(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLint*>(alpha_ptr) = float_to_i32(alpha);
+                break;
+            case GL_UNSIGNED_INT:
+                if (write_red)
+                    *reinterpret_cast<GLuint*>(red_ptr) = float_to_u32(red);
+                if (write_green)
+                    *reinterpret_cast<GLuint*>(green_ptr) = float_to_u32(green);
+                if (write_blue)
+                    *reinterpret_cast<GLuint*>(blue_ptr) = float_to_u32(blue);
+                if (write_alpha)
+                    *reinterpret_cast<GLuint*>(alpha_ptr) = float_to_u32(alpha);
+                break;
+            case GL_FLOAT:
+                if (write_red)
+                    *reinterpret_cast<GLfloat*>(red_ptr) = min(max(red, 0.0f), 1.0f);
+                if (write_green)
+                    *reinterpret_cast<GLfloat*>(green_ptr) = min(max(green, 0.0f), 1.0f);
+                if (write_blue)
+                    *reinterpret_cast<GLfloat*>(blue_ptr) = min(max(blue, 0.0f), 1.0f);
+                if (write_alpha)
+                    *reinterpret_cast<GLfloat*>(alpha_ptr) = min(max(alpha, 0.0f), 1.0f);
+                break;
+            }
+
+            out_ptr += component_size * component_count;
+        }
+    }
 }
 
 void SoftwareGLContext::present()
diff --git a/Userland/Libraries/LibGL/SoftwareRasterizer.cpp b/Userland/Libraries/LibGL/SoftwareRasterizer.cpp
index 4a35cf981d..9acca22a13 100644
--- a/Userland/Libraries/LibGL/SoftwareRasterizer.cpp
+++ b/Userland/Libraries/LibGL/SoftwareRasterizer.cpp
@@ -470,4 +470,22 @@ void SoftwareRasterizer::set_options(const RasterizerOptions& options)
     // FIXME: Recreate or reinitialize render threads here when multithreading is being implemented
 }
 
+Gfx::RGBA32 SoftwareRasterizer::get_backbuffer_pixel(int x, int y)
+{
+    // FIXME: Reading individual pixels is very slow, rewrite this to transfer whole blocks
+    if (x < 0 || y < 0 || x >= m_render_target->width() || y >= m_render_target->height())
+        return 0;
+
+    return m_render_target->scanline(y)[x];
+}
+
+float SoftwareRasterizer::get_depthbuffer_value(int x, int y)
+{
+    // FIXME: Reading individual pixels is very slow, rewrite this to transfer whole blocks
+    if (x < 0 || y < 0 || x >= m_render_target->width() || y >= m_render_target->height())
+        return 1.0f;
+
+    return m_depth_buffer->scanline(y)[x];
+}
+
 }
diff --git a/Userland/Libraries/LibGL/SoftwareRasterizer.h b/Userland/Libraries/LibGL/SoftwareRasterizer.h
index 62c7e66a73..841bbc5f55 100644
--- a/Userland/Libraries/LibGL/SoftwareRasterizer.h
+++ b/Userland/Libraries/LibGL/SoftwareRasterizer.h
@@ -38,6 +38,8 @@ public:
     void wait_for_all_threads() const;
     void set_options(const RasterizerOptions&);
     RasterizerOptions options() const { return m_options; }
+    Gfx::RGBA32 get_backbuffer_pixel(int x, int y);
+    float get_depthbuffer_value(int x, int y);
 
 private:
     RefPtr<Gfx::Bitmap> m_render_target;